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

autobyteus/rpc/server_main.py

@@ -1,198 +0,0 @@
-# file: autobyteus/autobyteus/rpc/server_main.py
-import asyncio
-import logging
-import argparse
-import signal
-import sys 
-from typing import Optional
-
-from autobyteus.agent.registry.agent_definition import AgentDefinition
-from autobyteus.agent.registry.agent_registry import default_definition_registry, default_agent_registry
-from autobyteus.agent.agent import Agent 
-from autobyteus.llm.models import LLMModel 
-
-from autobyteus.rpc.config import AgentServerConfig, default_agent_server_registry
-from autobyteus.rpc.server import AgentServerEndpoint
-from autobyteus.rpc.transport_type import TransportType
-
-try:
-    from autobyteus.agent.input_processor import PassthroughInputProcessor
-except ImportError:
-    print("WARNING: PassthroughInputProcessor not found, EchoAgentDefinition in server_main might fail if used.", file=sys.stderr)
-
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(name)s - [%(process)d] - %(message)s',
-    stream=sys.stderr
-)
-logger = logging.getLogger(__name__)
-
-
-ECHO_AGENT_DEF: Optional[AgentDefinition] = None
-try:
-    if not default_definition_registry.get("EchoAgent", "echo_responder"):
-        ECHO_AGENT_DEF = AgentDefinition(
-            name="EchoAgent",
-            role="echo_responder",
-            description="A simple agent that echoes back user messages.",
-            system_prompt="You are an echo agent. Repeat the user's message precisely.",
-            tool_names=[], 
-            input_processor_names=["PassthroughInputProcessor"], # Assumes PassthroughInputProcessor is registered
-            llm_response_processor_names=[] 
-        )
-        logger.info(f"Example AgentDefinition '{ECHO_AGENT_DEF.name}' created and auto-registered for server_main.")
-    else:
-        ECHO_AGENT_DEF = default_definition_registry.get("EchoAgent", "echo_responder")
-        logger.info(f"Example AgentDefinition 'EchoAgent' already registered. Using existing one for server_main.")
-except Exception as e:
-    logger.error(f"Could not create/retrieve example EchoAgentDefinition: {e}. server_main might fail if it's requested.")
-
-
-shutdown_event = asyncio.Event()
-agent_global: Optional[Agent] = None 
-server_endpoint_global: Optional[AgentServerEndpoint] = None
-
-async def main():
-    global agent_global, server_endpoint_global
-
-    parser = argparse.ArgumentParser(description="AutoByteUs Agent RPC Server") 
-    parser.add_argument("--agent-def-name", type=str, required=True, help="Name of the AgentDefinition.")
-    parser.add_argument("--agent-def-role", type=str, required=True, help="Role of the AgentDefinition.")
-    parser.add_argument("--llm-model-name", type=str, required=True, help="Name of the LLMModel (e.g., 'GPT_4o_API'). This is the string name for the model, not the enum member itself.")
-    parser.add_argument("--server-config-id", type=str, required=True, help="ID of the AgentServerConfig.")
-    
-    args = parser.parse_args()
-    logger.info(f"server_main starting with args: {args}")
-
-    agent_definition = default_definition_registry.get(args.agent_def_name, args.agent_def_role)
-    if not agent_definition:
-        logger.error(f"AgentDefinition not found for name='{args.agent_def_name}', role='{args.agent_def_role}'.")
-        sys.exit(1)
-
-    # The llm_model_name from args is already a string, which is what create_agent now expects.
-    # We still need to validate if it's a known model name for robustness,
-    # though create_agent (via AgentFactory -> AgentConfig) will also do this.
-    try:
-        LLMModel[args.llm_model_name.upper()] # Validate if the name maps to a known LLMModel enum member
-    except KeyError:
-        logger.error(f"LLMModel name '{args.llm_model_name}' provided via --llm-model-name is not a recognized LLMModel. Available: {[m.name for m in LLMModel]}")
-        sys.exit(1)
-
-    server_config = default_agent_server_registry.get_config(args.server_config_id)
-    if not server_config:
-        logger.error(f"AgentServerConfig not found for server_config_id='{args.server_config_id}'.")
-        sys.exit(1)
-    
-    try:
-        # UPDATED: Pass llm_model_name directly as a string.
-        # AgentRegistry.create_agent -> AgentFactory.create_agent_runtime -> AgentFactory.create_agent_context
-        # -> AgentConfig now takes llm_model_name: str.
-        agent = default_agent_registry.create_agent(
-            definition=agent_definition,
-            llm_model_name=args.llm_model_name # Pass the string name
-            # custom_llm_config, custom_tool_config, etc., can be added here if needed
-        )
-        agent_global = agent
-    except Exception as e:
-        logger.error(f"Failed to create Agent instance: {e}", exc_info=True)
-        sys.exit(1)
-    
-    logger.info(f"Agent instance created with agent_id '{agent.agent_id}'.")
-
-    server_endpoint = AgentServerEndpoint(agent) 
-    server_endpoint_global = server_endpoint
-    logger.info(f"AgentServerEndpoint instantiated for agent '{agent.agent_id}'.")
-
-    try:
-        logger.info(f"Starting Agent '{agent.agent_id}' (runtime execution loop)...")
-        agent.start()
-        
-        logger.info(f"Starting AgentServerEndpoint for agent '{agent.agent_id}' with config '{server_config.server_id}' (Transport: {server_config.transport_type.value})...")
-        await server_endpoint.start(server_config) 
-
-        logger.info(f"Agent '{agent.agent_id}' is now hosted and listening via RPC ({server_config.transport_type.value}).")
-        await shutdown_event.wait()
-
-    except Exception as e:
-        logger.error(f"Error during server startup or main execution: {e}", exc_info=True)
-    finally:
-        logger.info("server_main performing final shutdown...")
-        if server_endpoint_global and server_endpoint_global.is_running:
-            logger.info("Stopping AgentServerEndpoint...")
-            await server_endpoint_global.stop()
-        
-        if agent_global and agent_global.is_running: 
-            logger.info(f"Stopping Agent '{agent_global.agent_id}'...")
-            await agent_global.stop()
-        
-        logger.info("server_main has shut down.")
-
-async def initiate_shutdown_from_signal():
-    logger.debug("Initiating shutdown via signal...")
-    shutdown_event.set()
-
-if __name__ == "__main__":
-    # Ensure input processors are available if EchoAgentDefinition needs them
-    # This try-except is more for robustness during development/examples.
-    try:
-        # This import ensures that processors like PassthroughInputProcessor are registered
-        # if EchoAgentDefinition (or others used by server_main) depends on them.
-        from autobyteus.agent import input_processor # type: ignore
-    except ImportError as e_proc:
-        logger.warning(f"Could not import autobyteus.agent.input_processor: {e_proc}. "
-                       "Make sure custom input processors are correctly installed and registered if used by agent definitions.")
-
-
-    # Example STDIO server config (remains for testing server_main directly)
-    stdio_cfg_id = "default_stdio_server_cfg"
-    if not default_agent_server_registry.get_config(stdio_cfg_id):
-        example_stdio_cfg = AgentServerConfig(
-            server_id=stdio_cfg_id,
-            transport_type=TransportType.STDIO,
-            # stdio_command is usually for launching this script itself as a subprocess.
-            # For direct execution of server_main.py, this specific command isn't directly used
-            # but a valid config is needed if --server-config-id=default_stdio_server_cfg is passed.
-            stdio_command=["python", "-m", "autobyteus.rpc.server_main",
-                           "--agent-def-name", "EchoAgent", 
-                           "--agent-def-role", "echo_responder",
-                           "--llm-model-name", "GPT_4O_API", # Example model name
-                           "--server-config-id", stdio_cfg_id
-                          ] 
-        )
-        default_agent_server_registry.register_config(example_stdio_cfg)
-        logger.info(f"Registered example STDIOServerConfig '{stdio_cfg_id}'.")
-
-    # Example SSE server config
-    sse_cfg_id = "default_sse_server_cfg"
-    if not default_agent_server_registry.get_config(sse_cfg_id):
-        example_sse_cfg = AgentServerConfig(
-            server_id=sse_cfg_id, # This ID is for the server config itself
-            transport_type=TransportType.SSE,
-            sse_base_url="http://localhost:8765", 
-            sse_request_endpoint="/invoke_rpc", # Changed from /rpc to avoid clash with potential future global /rpc
-            sse_events_endpoint="/agent_events" # Changed from /events
-        )
-        default_agent_server_registry.register_config(example_sse_cfg)
-        logger.info(f"Registered example SseServerConfig '{sse_cfg_id}'.")
-
-    loop = asyncio.get_event_loop()
-    for sig_name_str in ('SIGINT', 'SIGTERM'):
-        sig_enum_member = getattr(signal, sig_name_str, None)
-        if sig_enum_member:
-            try:
-                loop.add_signal_handler(sig_enum_member, lambda s=sig_name_str: asyncio.create_task(initiate_shutdown_from_signal()))
-            except (ValueError, RuntimeError, NotImplementedError) as e: # Might fail on Windows for SIGTERM
-                 logger.warning(f"Could not set signal handler for {sig_name_str} on this platform: {e}.")
-    try:
-        loop.run_until_complete(main())
-    except KeyboardInterrupt:
-        logger.info("KeyboardInterrupt received in main. Shutting down.")
-        if not shutdown_event.is_set(): 
-            if loop.is_running():
-                asyncio.ensure_future(initiate_shutdown_from_signal(), loop=loop)
-            else: # Should not happen if loop was running
-                loop.run_until_complete(initiate_shutdown_from_signal())
-    finally:
-        logger.info("Asyncio loop in server_main is finalizing.")
-

autobyteus/rpc/transport_type.py

@@ -1,13 +0,0 @@
-# file: autobyteus/autobyteus/rpc/transport_type.py
-from enum import Enum
-
-class TransportType(str, Enum):
-    """
-    Defines the transport mechanisms supported for RPC communication.
-    """
-    STDIO = "stdio"
-    SSE = "sse"  # Server-Sent Events over HTTP
-
-    def __str__(self) -> str:
-        return self.value
-

autobyteus/tools/bash/__init__.py

@@ -1,2 +0,0 @@
-# This file makes 'bash' a package.
-# from .bash_executor import bash_executor # Optionally export

autobyteus/tools/bash/bash_executor.py

@@ -1,100 +0,0 @@
-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", category=ToolCategory.SYSTEM)
-async def bash_executor(context: Optional['AgentContext'], command: str) -> str:
-    """
-    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.
-    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"
-    
-    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:
-        # 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=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_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."
-            
-            logger.error(f"Command '{command}' failed with return code {process.returncode}: {error_message}")
-            raise subprocess.CalledProcessError(
-                returncode=process.returncode,
-                cmd=command,
-                output=stdout_output,
-                stderr=error_message
-            )
-        
-        # 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/__init__.py

@@ -1,2 +0,0 @@
-# This file makes 'browser' a package.
-# It can be empty or import submodules/subpackages.

autobyteus/tools/browser/session_aware/browser_session_aware_navigate_to.py

@@ -1,75 +0,0 @@
-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
-
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-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)
-        logger.debug("BrowserSessionAwareNavigateTo tool initialized.")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "NavigateTo"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return ("Navigates the shared browser session to a specified URL. "
-                "Returns a success or failure message based on navigation status.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="webpage_url",
-            param_type=ParameterType.STRING,
-            description="The fully qualified URL of the website to navigate to (e.g., 'https://example.com').",
-            required=True
-        ))
-        return schema
-    
-    async def perform_action(self, shared_session: SharedBrowserSession, webpage_url: str) -> str:
-        logger.info(f"BrowserSessionAwareNavigateTo performing action for URL: {webpage_url}")
-
-        if not self._is_valid_url(webpage_url):
-            raise ValueError(f"Invalid URL format: {webpage_url}. Must include scheme and netloc.")
-
-        try:
-            response = await shared_session.page.goto(webpage_url, wait_until="networkidle", timeout=60000)
-            
-            if response and response.ok:
-                success_msg = f"The NavigateTo command to {webpage_url} is executed successfully."
-                logger.info(success_msg)
-                return success_msg
-            else:
-                status = response.status if response else "Unknown"
-                failure_msg = f"The NavigationTo command to {webpage_url} failed with status {status}."
-                logger.warning(failure_msg)
-                return failure_msg
-        except Exception as e:
-            logger.error(f"Error during shared session navigation to '{webpage_url}': {e}", exc_info=True)
-            return f"Error navigating to {webpage_url}: {str(e)}"
-
-
-    @staticmethod
-    def _is_valid_url(url_string: str) -> bool:
-        try:
-            result = urlparse(url_string)
-            return all([result.scheme, result.netloc])
-        except ValueError:
-            return False

autobyteus/tools/browser/session_aware/browser_session_aware_tool.py

@@ -1,30 +0,0 @@
-# File: autobyteus/tools/browser/session_aware/browser_session_aware_tool.py
-
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.browser.session_aware.shared_browser_session_manager import SharedBrowserSessionManager
-from autobyteus.events.event_types import EventType
-from typing import Optional
-
-class BrowserSessionAwareTool(BaseTool):
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        self.shared_browser_session_manager = SharedBrowserSessionManager()
-
-    async def _execute(self, **kwargs):
-        shared_session = self.shared_browser_session_manager.get_shared_browser_session()
-        
-        if not shared_session:
-            webpage_url = kwargs.get('webpage_url')
-            if not webpage_url:
-                raise ValueError("The 'webpage_url' keyword argument must be specified when creating a new shared session.")
-            
-            await self.shared_browser_session_manager.create_shared_browser_session()
-            shared_session = self.shared_browser_session_manager.get_shared_browser_session()
-            await shared_session.page.goto(webpage_url)
-            self.emit(EventType.SHARED_BROWSER_SESSION_CREATED, shared_session=shared_session)
-        
-        return await self.perform_action(shared_session, **kwargs)
-
-    async def perform_action(self, shared_session, **kwargs):
-        raise NotImplementedError("Subclasses must implement this method")

autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py

@@ -1,154 +0,0 @@
-# File: autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py
-
-import xml.etree.ElementTree as ET
-from typing import Optional, TYPE_CHECKING, Dict, Any
-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.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    pass
-
-logger = logging.getLogger(__name__)
-
-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.")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "WebElementTrigger"
-
-    @classmethod
-    def get_description(cls) -> str:
-        action_names = ', '.join(str(action) for action in WebElementAction)
-        return (f"Triggers actions on web elements on the current page in a shared browser session. "
-                f"Supported actions: {action_names}. "
-                f"Returns a confirmation message upon successful execution.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="webpage_url",
-            param_type=ParameterType.STRING,
-            description="URL of the webpage. Required if no browser session is active or to ensure context.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="css_selector",
-            param_type=ParameterType.STRING,
-            description="CSS selector to find the target web element.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="action",
-            param_type=ParameterType.ENUM,
-            description=f"Type of interaction to perform. Must be one of: {', '.join(str(act) for act in WebElementAction)}.",
-            required=True,
-            enum_values=[str(act) for act in WebElementAction]
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="params",
-            param_type=ParameterType.STRING,
-            description="Optional XML-formatted string containing additional parameters for specific actions (e.g., text for 'type', option for 'select'). Example: <param><name>text</name><value>Hello</value></param>",
-            required=False 
-        ))
-        return schema
-        
-    async def perform_action(
-        self, 
-        shared_session: SharedBrowserSession, 
-        css_selector: str, 
-        action: str,
-        webpage_url: str,
-        params: Optional[str] = ""
-    ) -> str:
-        logger.info(f"WebElementTrigger performing action '{action}' on selector '{css_selector}' for page related to URL '{webpage_url}'. Params: '{params[:50]}...'")
-
-        try:
-            action_enum = WebElementAction.from_string(action)
-        except ValueError as e:
-            logger.error(f"Invalid action string '{action}' passed to perform_action despite schema validation: {e}")
-            raise
-
-        parsed_params = self._parse_xml_params(params if params else "")
-
-        element = shared_session.page.locator(css_selector)
-        
-        try:
-            await element.wait_for(state="visible", timeout=10000)
-        except Exception as e_wait:
-            error_msg = f"Element with selector '{css_selector}' not visible or found within timeout on page {shared_session.page.url}. Error: {e_wait}"
-            logger.warning(error_msg)
-            raise ValueError(error_msg) from e_wait
-
-        if action_enum == WebElementAction.CLICK:
-            await element.click()
-        elif action_enum == WebElementAction.TYPE:
-            text_to_type = parsed_params.get("text")
-            if text_to_type is None:
-                raise ValueError("'text' parameter is required for 'type' action.")
-            await element.fill("")
-            await element.type(text_to_type)
-        elif action_enum == WebElementAction.SELECT:
-            option_value = parsed_params.get("option")
-            if option_value is None:
-                raise ValueError("'option' parameter is required for 'select' action.")
-            await element.select_option(option_value)
-        elif action_enum == WebElementAction.CHECK:
-            state_str = parsed_params.get("state", "true")
-            is_checked_state = state_str.lower() == "true"
-            if is_checked_state:
-                await element.check()
-            else:
-                await element.uncheck()
-        elif action_enum == WebElementAction.SUBMIT:
-            logger.warning("WebElementAction.SUBMIT is interpreted as a click. Ensure CSS selector targets a submit button or form element intended for click-based submission.")
-            await element.click()
-        elif action_enum == WebElementAction.HOVER:
-            await element.hover()
-        elif action_enum == WebElementAction.DOUBLE_CLICK:
-            await element.dblclick()
-        else:
-            raise ValueError(f"Unsupported action: {action_enum}")
-
-        success_msg = f"The WebElementTrigger action '{action_enum}' on selector '{css_selector}' was executed."
-        logger.info(success_msg)
-        return success_msg
-
-    def _parse_xml_params(self, params_xml_str: str) -> Dict[str, str]:
-        if not params_xml_str:
-            return {}
-        
-        try:
-            if not params_xml_str.strip().startswith("<root>"):
-                 xml_string_to_parse = f"<root>{params_xml_str}</root>"
-            else:
-                 xml_string_to_parse = params_xml_str
-                 
-            root = ET.fromstring(xml_string_to_parse)
-            parsed_params: Dict[str, str] = {}
-            for param_node in root.findall('param'):
-                name_elem = param_node.find('name')
-                value_elem = param_node.find('value')
-                if name_elem is not None and name_elem.text and value_elem is not None and value_elem.text is not None:
-                    parsed_params[name_elem.text] = value_elem.text
-                elif name_elem is not None and name_elem.text and value_elem is not None and value_elem.text is None:
-                     parsed_params[name_elem.text] = ""
-
-            return parsed_params
-        except ET.ParseError as e_parse:
-            logger.warning(f"Failed to parse params XML string: '{params_xml_str}'. Error: {e_parse}. Returning empty params.")
-            return {}

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_reader.py

@@ -1,89 +0,0 @@
-# File: autobyteus/tools/browser/session_aware/browser_session_aware_webpage_reader.py
-
-import logging
-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.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
-from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.utils.html_cleaner import clean, CleaningMode
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__)
-
-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)
-        
-        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:
-                        cleaning_mode_to_use = CleaningMode.THOROUGH
-                elif isinstance(cleaning_mode_value, CleaningMode):
-                    cleaning_mode_to_use = cleaning_mode_value
-        
-        self.cleaning_mode = cleaning_mode_to_use
-        logger.debug(f"BrowserSessionAwareWebPageReader initialized with cleaning_mode: {self.cleaning_mode}")
-
-    @classmethod
-    def get_name(cls) -> str: 
-        return "WebPageReader"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return ("Reads and cleans the HTML content from the current page in a shared browser session. "
-                "The level of HTML cleanup can be configured at tool instantiation.")
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="webpage_url", 
-            param_type=ParameterType.STRING,
-            description="URL of the webpage. Required if no browser session is active or to ensure context. Tool reads current page content after navigation if applicable.",
-            required=True 
-        ))
-        return schema
-
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]: 
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="cleaning_mode",
-            param_type=ParameterType.ENUM,
-            description="Level of HTML content cleanup (BASIC or THOROUGH). Applied to the read webpage content.",
-            required=False,
-            default_value="THOROUGH",
-            enum_values=[mode.name for mode in CleaningMode]
-        ))
-        return schema
-
-    async def perform_action(
-        self, 
-        shared_session: SharedBrowserSession,
-        webpage_url: str 
-    ) -> str: 
-        logger.info(f"BrowserSessionAwareWebPageReader performing action. Current page URL: {shared_session.page.url}, cleaning_mode: {self.cleaning_mode}")
-        
-        try:
-            page_content = await shared_session.page.content()
-            cleaned_content = clean(page_content, self.cleaning_mode)
-            logger.debug(f"Read and cleaned content from {shared_session.page.url}. Cleaned length: {len(cleaned_content)}")
-            return cleaned_content
-        except Exception as e:
-            logger.error(f"Error reading page content in shared session from {shared_session.page.url}: {e}", exc_info=True)
-            raise RuntimeError(f"Failed to read page content from shared session: {str(e)}")