autobyteus 1.0.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py

@@ -1,159 +1,151 @@
 # File: autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py
 
-from datetime import datetime
-import os
 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.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.tool_config import ToolConfig
 
-class BrowserSessionAwareWebElementTrigger(BrowserSessionAwareTool):
-    def __init__(self):
-        super().__init__()
-
-    def get_name(self) -> str:
-        return "WebElementTrigger"
-    
-    @classmethod
-    def tool_usage_xml(cls):
-        """
-        Return an XML string describing the usage of the WebElementTrigger tool.
-
-        Returns:
-            str: An XML description of how to use the WebElementTrigger tool.
-        """
-        return f'''WebElementTrigger: Triggers actions on web elements on web pages, takes a screenshot, and returns the absolute path of the screenshot.
-    <command name="WebElementTrigger">
-      <arg name="webpage_url">url</arg>
-      <arg name="css_selector">selector</arg>
-      <arg name="action">action</arg>
-      <arg name="params">
-        <param>
-          <name>param_name</name>
-          <value>param_value</value>
-        </param>
-      </arg>
-    </command>
-
-    Parameters:
-    - webpage_url: String. URL of the webpage to interact with.
-    - css_selector: String. CSS selector to find the target element.
-    - action: String. Type of interaction to perform on the element. Must be one of: 
-      {', '.join(str(action) for action in WebElementAction)}
-    - params: XML-formatted string containing additional parameters for specific actions.
-
-    Common actions and their parameters:
-    1. click: No additional params required.
-    2. type: Requires 'text' param. Example: <param><name>text</name><value>Hello, World!</value></param>
-    3. select: Requires 'option' param. Example: <param><name>option</name><value>option1</value></param>
-    4. check: Optional 'state' param (default: true). Example: <param><name>state</name><value>false</value></param>
-    5. submit: No additional params required.
-    6. hover: No additional params required.
-    7. double_click: No additional params required.
+if TYPE_CHECKING:
+    pass
 
-    Return Value:
-    - String: Absolute path to the screenshot taken after the action is performed.
-      The screenshot is saved in the current working directory with the filename format:
-      'screenshot_<action>_<timestamp>.png'
+logger = logging.getLogger(__name__)
 
-    Examples:
-    1. Typing in a search box:
-      <command name="WebElementTrigger">
-        <arg name="webpage_url">https://example.com</arg>
-        <arg name="css_selector">#search-input</arg>
-        <arg name="action">type</arg>
-        <arg name="params">
-          <param>
-            <name>text</name>
-            <value>Python tutorial</value>
-          </param>
-        </arg>
-      </command>
-      Returns: '/path/to/screenshot_type_20230615_120530.png'
-
-    2. Selecting an option from a dropdown:
-      <command name="WebElementTrigger">
-        <arg name="webpage_url">https://example.com</arg>
-        <arg name="css_selector">#country-select</arg>
-        <arg name="action">select</arg>
-        <arg name="params">
-          <param>
-            <name>option</name>
-            <value>USA</value>
-          </param>
-        </arg>
-      </command>
-      Returns: '/path/to/screenshot_select_20230615_120545.png'
+class BrowserSessionAwareWebElementTrigger(BrowserSessionAwareTool):
+    """
+    A session-aware tool to trigger actions on web elements identified by a CSS selector.
+    """
+    def __init__(self, config: Optional[ToolConfig] = None):
+        super().__init__(config=config)
+        logger.debug("BrowserSessionAwareWebElementTrigger tool initialized.")
 
-    3. Clicking a button:
-      <command name="WebElementTrigger">
-        <arg name="webpage_url">https://example.com</arg>
-        <arg name="css_selector">.submit-button</arg>
-        <arg name="action">click</arg>
-      </command>
-      Returns: '/path/to/screenshot_click_20230615_120600.png'
-    '''
+    @classmethod
+    def get_name(cls) -> str:
+        return "WebElementTrigger"
 
-    async def perform_action(self, shared_session: SharedBrowserSession, **kwargs):
-        css_selector = kwargs.get("css_selector")
-        action_str = kwargs.get("action")
-        params_str = kwargs.get("params", "")
+    @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.")
 
-        if not css_selector:
-            raise ValueError("CSS selector is required.")
+    @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 = WebElementAction.from_string(action_str)
+            action_enum = WebElementAction.from_string(action)
         except ValueError as e:
-            raise ValueError(f"Invalid action: {action_str}. {str(e)}")
+            logger.error(f"Invalid action string '{action}' passed to perform_action despite schema validation: {e}")
+            raise
 
-        params = self._parse_params(params_str)
+        parsed_params = self._parse_xml_params(params if params else "")
 
         element = shared_session.page.locator(css_selector)
         
-        if action == WebElementAction.CLICK:
+        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 == WebElementAction.TYPE:
-            text = params.get("text")
-            if not text:
+        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.type(text)
-        elif action == WebElementAction.SELECT:
-            option = params.get("option")
-            if not option:
+            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)
-        elif action == WebElementAction.CHECK:
-            state = params.get("state", "true").lower() == "true"
-            if state:
+            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 == WebElementAction.SUBMIT:
-            await element.submit()
-        elif action == WebElementAction.HOVER:
+        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 == WebElementAction.DOUBLE_CLICK:
+        elif action_enum == WebElementAction.DOUBLE_CLICK:
             await element.dblclick()
         else:
-            raise ValueError(f"Unsupported action: {action}")
+            raise ValueError(f"Unsupported action: {action_enum}")
 
-        # Take screenshot after action
-        return "The WebElementTrigger command is executed"
+        success_msg = f"The WebElementTrigger action '{action_enum}' on selector '{css_selector}' was executed."
+        logger.info(success_msg)
+        return success_msg
 
-    def _parse_params(self, params_str):
-        if not params_str:
+    def _parse_xml_params(self, params_xml_str: str) -> Dict[str, str]:
+        if not params_xml_str:
             return {}
         
         try:
-            xml_string = f"<root>{params_str}</root>"
-            root = ET.fromstring(xml_string)
-            params = {}
-            for param in root.findall('param'):
-                name_elem = param.find('name')
-                value_elem = param.find('value')
-                if name_elem is not None and value_elem is not None:
-                    params[name_elem.text] = value_elem.text
-            return params
-        except ET.ParseError:
+            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,33 +1,86 @@
 # 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.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext 
+
+logger = logging.getLogger(__name__)
+
 class BrowserSessionAwareWebPageReader(BrowserSessionAwareTool):
-    def __init__(self, cleaning_mode=CleaningMode.THOROUGH):
-        super().__init__()
-        self.cleaning_mode = cleaning_mode
+    """
+    A session-aware tool to read and clean HTML content from the current page
+    in a shared browser session.
+    """
+    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}")
 
-    def get_name(self) -> str:
+    @classmethod
+    def get_name(cls) -> str: 
         return "WebPageReader"
 
     @classmethod
-    def tool_usage_xml(cls):
-        """
-        Return an XML string describing the usage of the WebPageReader tool.
-
-        Returns:
-            str: An XML description of how to use the WebPageReader tool.
-        """
-        return '''WebPageReader: Reads and cleans the HTML content from a given webpage. Usage:
-<command name="WebPageReader">
-  <arg name="webpage_url">url_to_read</arg>
-</command>
-where "url_to_read" is a string containing the URL of the webpage to read the content from.
-'''
-
-    async def perform_action(self, shared_session: SharedBrowserSession, **kwargs):
-        page_content = await shared_session.page.content()
-        cleaned_content = clean(page_content, self.cleaning_mode)
-        return cleaned_content
+    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)}")

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_screenshot_taker.py

@@ -1,38 +1,104 @@
 # File: autobyteus/tools/browser/session_aware/browser_session_aware_webpage_screenshot_taker.py
 
 import os
+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.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext 
+
+logger = logging.getLogger(__name__) 
 
 class BrowserSessionAwareWebPageScreenshotTaker(BrowserSessionAwareTool):
-    def __init__(self):
-        super().__init__()
+    """
+    A session-aware tool to take a screenshot of the current page in a shared browser session.
+    """
+    def __init__(self, config: Optional[ToolConfig] = None): 
+        super().__init__(config=config)
+        
+        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"BrowserSessionAwareWebPageScreenshotTaker initialized. Full page: {self.full_page}, Format: {self.image_format}")
 
-    def get_name(self) -> str:
-        return "WebPageScreenshotTaker"
+    @classmethod
+    def get_name(cls) -> str: 
+        return "WebPageScreenshotTaker" 
+
+    @classmethod
+    def get_description(cls) -> str:
+        return ("Takes a screenshot of the current page in a shared browser session. "
+                "Saves it to the specified local file path and returns the absolute path of the saved screenshot. "
+                "Screenshot options (full page, image format) can be set at tool instantiation.")
 
     @classmethod
-    def tool_usage_xml(cls):
-        """
-        Return an XML string describing the usage of the WebPageScreenshotTaker tool.
-
-        Returns:
-            str: An XML description of how to use the WebPageScreenshotTaker tool.
-        """
-        return '''WebPageScreenshotTaker: Takes a screenshot of a given webpage and saves it to the specified file. Usage:
-<command name="WebPageScreenshotTaker">
-  <arg name="webpage_url">url_to_screenshot</arg>
-  <arg name="file_name">screenshot_file_name</arg>
-</command>
-where "url_to_screenshot" is a string containing the URL of the webpage to take a screenshot of, and "screenshot_file_name" is the name of the file to save the screenshot (including extension, e.g., 'screenshot.png'). Optionally, "screenshot_file_name" can include a relative path (e.g., 'images/screenshot.png').
-Returns the absolute file path of the saved screenshot.
-'''
-
-    async def perform_action(self, shared_session: SharedBrowserSession, **kwargs):
-        file_name = kwargs.get('file_name')
-        if not file_name:
-            raise ValueError("The 'file_name' keyword argument must be specified.")
-
-        await shared_session.page.screenshot(path=file_name, full_page=True)
-        absolute_path = os.path.abspath(file_name)
-        return absolute_path
+    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. Screenshot is of current page.",
+            required=True 
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="file_name", 
+            param_type=ParameterType.STRING,
+            description="The local file path (including filename and extension, e.g., 'session_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="Default for whether to capture the full scrollable page or just the viewport.",
+            required=False,
+            default_value=True
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="image_format",
+            param_type=ParameterType.ENUM,
+            description="Default image format for screenshots (png or jpeg).",
+            required=False,
+            default_value="png",
+            enum_values=["png", "jpeg"]
+        ))
+        return schema
+
+    async def perform_action(
+        self, 
+        shared_session: SharedBrowserSession, 
+        file_name: str, 
+        webpage_url: str 
+    ) -> str: 
+        logger.info(f"BrowserSessionAwareWebPageScreenshotTaker performing action. Saving to '{file_name}'. Current page: {shared_session.page.url}")
+
+        output_dir = os.path.dirname(file_name)
+        if output_dir: 
+            os.makedirs(output_dir, exist_ok=True)
+            
+        try:
+            await shared_session.page.screenshot(
+                path=file_name, 
+                full_page=self.full_page, 
+                type=self.image_format # type: ignore
+            )
+            absolute_file_path = os.path.abspath(file_name)
+            logger.info(f"Screenshot of {shared_session.page.url} saved successfully to {absolute_file_path}")
+            return absolute_file_path
+        except Exception as e:
+            logger.error(f"Error taking screenshot in shared session for page {shared_session.page.url}, saving to '{file_name}': {e}", exc_info=True)
+            raise RuntimeError(f"Failed to take screenshot in shared session: {str(e)}")

autobyteus/tools/browser/session_aware/factory/browser_session_aware_web_element_trigger_factory.py

@@ -1,6 +1,14 @@
 from autobyteus.tools.factory.tool_factory import ToolFactory
 from autobyteus.tools.browser.session_aware.browser_session_aware_web_element_trigger import BrowserSessionAwareWebElementTrigger
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.tools.tool_config import ToolConfig
 
 class BrowserSessionAwareWebElementTriggerFactory(ToolFactory):
-    def create_tool(self) -> BrowserSessionAwareWebElementTrigger:
-        return BrowserSessionAwareWebElementTrigger()
+    def create_tool(self, config: Optional['ToolConfig'] = None) -> BrowserSessionAwareWebElementTrigger:
+        """
+        Creates an instance of BrowserSessionAwareWebElementTrigger.
+        The 'config' parameter is ignored by this factory.
+        """
+        return BrowserSessionAwareWebElementTrigger()

autobyteus/tools/browser/session_aware/factory/browser_session_aware_webpage_reader_factory.py

@@ -1,10 +1,26 @@
 from autobyteus.tools.factory.tool_factory import ToolFactory
 from autobyteus.tools.browser.session_aware.browser_session_aware_webpage_reader import BrowserSessionAwareWebPageReader
 from autobyteus.utils.html_cleaner import CleaningMode
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.tools.tool_config import ToolConfig
+    from autobyteus.tools.base_tool import BaseTool
 
 class BrowserSessionAwareWebPageReaderFactory(ToolFactory):
     def __init__(self, content_cleanup_level: CleaningMode = CleaningMode.THOROUGH):
         self.content_cleanup_level = content_cleanup_level
 
-    def create_tool(self) -> BrowserSessionAwareWebPageReader:
-        return BrowserSessionAwareWebPageReader(cleaning_mode=self.content_cleanup_level)
+    def create_tool(self, config: Optional['ToolConfig'] = None) -> BrowserSessionAwareWebPageReader:
+        """
+        Creates an instance of BrowserSessionAwareWebPageReader.
+        The 'config' parameter is ignored; configuration is set during factory initialization.
+        """
+        # This factory passes its own configuration to the tool's constructor.
+        # The tool's constructor expects a ToolConfig object.
+        from autobyteus.tools.tool_config import ToolConfig as ConcreteToolConfig
+        
+        tool_creation_config = ConcreteToolConfig(
+            params={"cleaning_mode": self.content_cleanup_level}
+        )
+        return BrowserSessionAwareWebPageReader(config=tool_creation_config)

autobyteus/tools/browser/session_aware/factory/browser_session_aware_webpage_screenshot_taker_factory.py

@@ -1,6 +1,14 @@
 from autobyteus.tools.factory.tool_factory import ToolFactory
 from autobyteus.tools.browser.session_aware.browser_session_aware_webpage_screenshot_taker import BrowserSessionAwareWebPageScreenshotTaker
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.tools.tool_config import ToolConfig
 
 class BrowserSessionAwareWebPageScreenshotTakerFactory(ToolFactory):
-    def create_tool(self) -> BrowserSessionAwareWebPageScreenshotTaker:
-        return BrowserSessionAwareWebPageScreenshotTaker()
+    def create_tool(self, config: Optional['ToolConfig'] = None) -> BrowserSessionAwareWebPageScreenshotTaker:
+        """
+        Creates an instance of BrowserSessionAwareWebPageScreenshotTaker.
+        The 'config' parameter is ignored by this factory.
+        """
+        return BrowserSessionAwareWebPageScreenshotTaker()

autobyteus/tools/browser/session_aware/shared_browser_session_manager.py

@@ -1,14 +1,15 @@
 from autobyteus.utils.singleton import SingletonMeta
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.events.event_emitter import EventEmitter
+from autobyteus.events.event_types import EventType
 
 class SharedBrowserSessionManager(metaclass=SingletonMeta):
     def __init__(self):
         self.shared_browser_session = None
         self.event_emitter = EventEmitter()
-        self.event_emitter.subscribe("create_shared_session", self.create_shared_browser_session)
+        self.event_emitter.subscribe(EventType.CREATE_SHARED_SESSION, self.create_shared_browser_session)
 
-    async def create_shared_browser_session(self):
+    async def create_shared_browser_session(self, **kwargs):
         self.shared_browser_session = SharedBrowserSession()
         await self.shared_browser_session.initialize()
 
@@ -21,4 +22,4 @@ class SharedBrowserSessionManager(metaclass=SingletonMeta):
         self.shared_browser_session = shared_session
 
     def get_shared_browser_session(self):
-        return self.shared_browser_session
+        return self.shared_browser_session

autobyteus/tools/browser/standalone/__init__.py

@@ -0,0 +1,7 @@
+# This file makes 'standalone' a package under 'browser'.
+# from .google_search_ui import GoogleSearch
+# from .webpage_reader import WebPageReader
+# from .webpage_screenshot_taker import WebPageScreenshotTaker
+# from .navigate_to import NavigateTo
+# from .webpage_image_downloader import WebPageImageDownloader
+# from .web_page_pdf_generator import WebPagePDFGenerator

autobyteus/tools/browser/standalone/factory/google_search_factory.py

@@ -1,10 +1,25 @@
 from autobyteus.tools.factory.tool_factory import ToolFactory
 from autobyteus.tools.browser.standalone.google_search_ui import GoogleSearch
 from autobyteus.utils.html_cleaner import CleaningMode
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.tools.tool_config import ToolConfig
 
 class GoogleSearchFactory(ToolFactory):
     def __init__(self, cleaning_mode: CleaningMode = CleaningMode.THOROUGH):
         self.cleaning_mode = cleaning_mode
 
-    def create_tool(self) -> GoogleSearch:
-        return GoogleSearch(cleaning_mode=self.cleaning_mode)
+    def create_tool(self, config: Optional['ToolConfig'] = None) -> GoogleSearch:
+        """
+        Creates an instance of GoogleSearch.
+        The 'config' parameter is ignored; configuration is set during factory initialization.
+        """
+        # This factory passes its own configuration to the tool's constructor.
+        # The tool's constructor expects a ToolConfig object.
+        from autobyteus.tools.tool_config import ToolConfig as ConcreteToolConfig
+
+        tool_creation_config = ConcreteToolConfig(
+            params={"cleaning_mode": self.cleaning_mode}
+        )
+        return GoogleSearch(config=tool_creation_config)