camel-ai 0.2.71a5__py3-none-any.whl → 0.2.71a6__py3-none-any.whl

camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py

@@ -15,9 +15,11 @@
 import base64
 import datetime
 import io
+import json
 import os
 import time
 import urllib.parse
+from functools import wraps
 from typing import Any, Callable, ClassVar, Dict, List, Optional, cast
 
 from camel.logger import get_logger
@@ -26,9 +28,10 @@ from camel.toolkits.base import BaseToolkit
 from camel.toolkits.function_tool import FunctionTool
 from camel.utils import sanitize_filename
 from camel.utils.commons import dependencies_required
+from camel.utils.tool_result import ToolResult
 
 from .agent import PlaywrightLLMAgent
-from .browser_session import NVBrowserSession
+from .browser_session import HybridBrowserSession
 
 logger = get_logger(__name__)
 
@@ -54,9 +57,11 @@ class HybridBrowserToolkit(BaseToolkit):
         "open_browser",
         "close_browser",
         "visit_page",
+        "back",
+        "forward",
         "click",
         "type",
-        "enter",
+        "switch_tab",
     ]
 
     # All available tools
@@ -64,6 +69,8 @@ class HybridBrowserToolkit(BaseToolkit):
         "open_browser",
         "close_browser",
         "visit_page",
+        "back",
+        "forward",
         "get_page_snapshot",
         "get_som_screenshot",
         "get_page_links",
@@ -74,6 +81,9 @@ class HybridBrowserToolkit(BaseToolkit):
         "enter",
         "wait_user",
         "solve_task",
+        "switch_tab",
+        "close_tab",
+        "get_tab_info",
     ]
 
     def __init__(
@@ -81,9 +91,13 @@ class HybridBrowserToolkit(BaseToolkit):
         *,
         headless: bool = True,
         user_data_dir: Optional[str] = None,
+        stealth: bool = False,
         web_agent_model: Optional[BaseModelBackend] = None,
         cache_dir: str = "tmp/",
         enabled_tools: Optional[List[str]] = None,
+        browser_log_to_file: bool = False,
+        session_id: Optional[str] = None,
+        default_start_url: str = "https://google.com/",
     ) -> None:
         r"""Initialize the HybridBrowserToolkit.
 
@@ -94,6 +108,12 @@ class HybridBrowserToolkit(BaseToolkit):
                 browser data like cookies and local storage. Useful for
                 maintaining sessions across runs. Defaults to `None` (a
                 temporary directory is used).
+            stealth (bool): Whether to run the browser in stealth mode to avoid
+                bot detection. When enabled, hides WebDriver characteristics,
+                spoofs navigator properties, and implements various
+                anti-detection
+                measures. Highly recommended for production use and when
+                accessing sites with bot detection. Defaults to `False`.
             web_agent_model (Optional[BaseModelBackend]): The language model
                 backend to use for the high-level `solve_task` agent. This is
                 required only if you plan to use `solve_task`.
@@ -102,18 +122,57 @@ class HybridBrowserToolkit(BaseToolkit):
                 screenshots. Defaults to `"tmp/"`.
             enabled_tools (Optional[List[str]]): List of tool names to enable.
                 If None, uses DEFAULT_TOOLS. Available tools: open_browser,
-                close_browser, visit_page, get_page_snapshot,
+                close_browser, visit_page, back, forward, get_page_snapshot,
                 get_som_screenshot, get_page_links, click, type, select,
                 scroll, enter, wait_user, solve_task.
                 Defaults to `None`.
+            browser_log_to_file (bool): Whether to save detailed browser
+            action logs to file.
+                When enabled, logs action inputs/outputs, execution times,
+                and page loading times.
+                Logs are saved to an auto-generated timestamped file.
+                Defaults to `False`.
+            session_id (Optional[str]): A unique identifier for this browser
+                session. When multiple HybridBrowserToolkit instances are used
+                concurrently, different session IDs prevent them from sharing
+                the same browser session and causing conflicts. If None, a
+                default session will be used. Defaults to `None`.
+            default_start_url (str): The default URL to navigate to when
+                open_browser() is called without a start_url parameter or with
+                None. Defaults to `"https://google.com/"`.
         """
         super().__init__()
         self._headless = headless
         self._user_data_dir = user_data_dir
         self.web_agent_model = web_agent_model
         self.cache_dir = cache_dir
+        self.default_start_url = default_start_url
         os.makedirs(self.cache_dir, exist_ok=True)
 
+        # Logging configuration - fixed values for simplicity
+        self.enable_action_logging = True
+        self.enable_timing_logging = True
+        self.enable_page_loading_logging = True
+        self.log_to_console = False  # Always disabled for cleaner output
+        self.log_to_file = browser_log_to_file
+        self.max_log_length = None  # No truncation for file logs
+
+        # Set up log file if needed
+        if self.log_to_file:
+            # Create log directory if it doesn't exist
+            log_dir = "browser_log"
+            os.makedirs(log_dir, exist_ok=True)
+
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            self.log_file_path: Optional[str] = os.path.join(
+                log_dir, f"hybrid_browser_toolkit_{timestamp}_{session_id}.log"
+            )
+        else:
+            self.log_file_path = None
+
+        # Initialize log buffer for in-memory storage
+        self.log_buffer: List[Dict[str, Any]] = []
+
         # Configure enabled tools
         if enabled_tools is None:
             self.enabled_tools = self.DEFAULT_TOOLS.copy()
@@ -131,10 +190,23 @@ class HybridBrowserToolkit(BaseToolkit):
 
         logger.info(f"Enabled tools: {self.enabled_tools}")
 
+        # Log initialization if file logging is enabled
+        if self.log_to_file:
+            logger.info(
+                "HybridBrowserToolkit initialized with file logging enabled"
+            )
+            logger.info(f"Log file path: {self.log_file_path}")
+
         # Core components
-        self._session = NVBrowserSession(
-            headless=headless, user_data_dir=user_data_dir
+        temp_session = HybridBrowserSession(
+            headless=headless,
+            user_data_dir=user_data_dir,
+            stealth=stealth,
+            session_id=session_id,
         )
+        # Use the session directly - singleton logic is handled in
+        # ensure_browser
+        self._session = temp_session
         self._agent: Optional[PlaywrightLLMAgent] = None
         self._unified_script = self._load_unified_analyzer()
 
@@ -151,7 +223,13 @@ class HybridBrowserToolkit(BaseToolkit):
             try:
                 loop = asyncio.get_event_loop()
                 if not loop.is_closed() and not loop.is_running():
-                    loop.run_until_complete(self.close_browser())
+                    # Try to close browser with a timeout to prevent hanging
+                    try:
+                        loop.run_until_complete(
+                            asyncio.wait_for(self.close_browser(), timeout=2.0)
+                        )
+                    except asyncio.TimeoutError:
+                        pass  # Skip cleanup if it takes too long
             except (RuntimeError, ImportError):
                 pass  # Event loop unavailable, skip cleanup
         except Exception:
@@ -186,12 +264,176 @@ class HybridBrowserToolkit(BaseToolkit):
                 f"{method_name}: 'ref' must be a non-empty string"
             )
 
+    def _truncate_if_needed(self, content: Any) -> str:
+        r"""Truncate content if max_log_length is set."""
+        content_str = str(content)
+        if (
+            self.max_log_length is not None
+            and len(content_str) > self.max_log_length
+        ):
+            return content_str[: self.max_log_length] + "... [TRUNCATED]"
+        return content_str
+
+    async def _get_current_url(self) -> Optional[str]:
+        r"""Safely get the current URL of the active page."""
+        try:
+            page = await self._session.get_page()
+            if page and not page.is_closed():
+                return page.url
+            return None  # Return None if page is closed
+        except Exception:
+            # This can happen if browser is not open.
+            return None
+
+    async def _log_action(
+        self,
+        action_name: str,
+        inputs: Dict[str, Any],
+        outputs: Any,
+        execution_time: float,
+        page_load_time: Optional[float] = None,
+        error: Optional[str] = None,
+    ) -> None:
+        r"""Log action details with comprehensive information."""
+        if not (self.enable_action_logging or self.enable_timing_logging):
+            return
+
+        current_url = await self._get_current_url()
+
+        log_entry: Dict[str, Any] = {
+            "timestamp": datetime.datetime.now().isoformat(),
+            "action": action_name,
+            "url": current_url,
+            "execution_time_ms": round(execution_time * 1000, 2),
+        }
+
+        if self.enable_action_logging:
+            log_entry["inputs"] = inputs
+            if error:
+                log_entry["error"] = str(error)
+            elif isinstance(outputs, dict):
+                # Unpack dictionary items into the log entry
+                log_entry.update(outputs)
+            elif isinstance(outputs, ToolResult):
+                log_entry["outputs"] = {
+                    "text": outputs.text,
+                    "images": outputs.images,
+                }
+            else:
+                # For non-dict outputs, assign to 'outputs' key
+                log_entry["outputs"] = outputs
+
+        if page_load_time is not None and self.enable_page_loading_logging:
+            log_entry["page_load_time_ms"] = round(page_load_time * 1000, 2)
+
+        # Add to buffer
+        self.log_buffer.append(log_entry)
+
+        # Console logging
+        if self.log_to_console:
+            log_msg = f"[BROWSER ACTION] {action_name}"
+            if self.enable_timing_logging:
+                log_msg += f" | Execution: {log_entry['execution_time_ms']}ms"
+            if page_load_time is not None and self.enable_page_loading_logging:
+                log_msg += f" | Page Load: {log_entry['page_load_time_ms']}ms"
+            if error:
+                log_msg += f" | ERROR: {error}"
+
+            logger.info(log_msg)
+
+            if self.enable_action_logging:
+                logger.info(f"  Inputs: {self._truncate_if_needed(inputs)}")
+                if not error:
+                    if isinstance(outputs, dict):
+                        for key, value in outputs.items():
+                            logger.info(
+                                f"  - {key}: "
+                                f"{self._truncate_if_needed(value)}"
+                            )
+                    else:
+                        logger.info(
+                            f"  Outputs: {self._truncate_if_needed(outputs)}"
+                        )
+
+        # File logging
+        if self.log_to_file and self.log_file_path:
+            try:
+                with open(self.log_file_path, 'a', encoding='utf-8') as f:
+                    # Write full log entry to file without truncation
+                    f.write(
+                        json.dumps(log_entry, ensure_ascii=False, indent=2)
+                        + '\n'
+                    )
+            except Exception as e:
+                logger.error(f"Failed to write to log file: {e}")
+
+    @staticmethod
+    def action_logger(func: Callable[..., Any]) -> Callable[..., Any]:
+        r"""Decorator to add logging to action methods."""
+
+        @wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            action_name = func.__name__
+            start_time = time.time()
+
+            # Log inputs
+            inputs = {
+                "args": args,  # Don't skip self since it's already handled
+                "kwargs": kwargs,
+            }
+
+            try:
+                # Execute the original function
+                result = await func(self, *args, **kwargs)
+                execution_time = time.time() - start_time
+
+                # Log success
+                await self._log_action(
+                    action_name=action_name,
+                    inputs=inputs,
+                    outputs=result,
+                    execution_time=execution_time,
+                )
+
+                return result
+
+            except Exception as e:
+                execution_time = time.time() - start_time
+                error_msg = f"{type(e).__name__}: {e!s}"
+
+                # Log error
+                await self._log_action(
+                    action_name=action_name,
+                    inputs=inputs,
+                    outputs=None,
+                    execution_time=execution_time,
+                    error=error_msg,
+                )
+
+                raise
+
+        return wrapper
+
+    async def _get_session(self) -> "HybridBrowserSession":
+        """Get the correct singleton session instance."""
+        singleton = await HybridBrowserSession._get_or_create_instance(
+            self._session
+        )
+        if singleton is not self._session:
+            logger.debug("Updating to singleton session instance")
+            self._session = singleton
+        return self._session
+
     async def _ensure_browser(self):
-        await self._session.ensure_browser()
+        # Get singleton instance and update self._session if needed
+        session = await self._get_session()
+        await session.ensure_browser()
 
     async def _require_page(self):
-        await self._session.ensure_browser()
-        return await self._session.get_page()
+        # Get singleton instance and update self._session if needed
+        session = await self._get_session()
+        await session.ensure_browser()
+        return await session.get_page()
 
     async def _wait_for_page_stability(self):
         r"""Wait for page to become stable after actions that might trigger
@@ -370,8 +612,108 @@ class HybridBrowserToolkit(BaseToolkit):
 
         return "\n".join(lines)
 
+    async def _get_tab_info_for_output(self) -> Dict[str, Any]:
+        r"""Get tab information to include in action outputs."""
+        try:
+            # Ensure we have the correct singleton session instance first
+            session = await self._get_session()
+
+            # Add debug info for tab info retrieval
+            logger.debug("Attempting to get tab info from session...")
+            tab_info = await session.get_tab_info()
+            current_tab_index = await session.get_current_tab_index()
+
+            # Debug log the successful retrieval
+            logger.debug(
+                f"Successfully retrieved {len(tab_info)} tabs, current: "
+                f"{current_tab_index}"
+            )
+
+            return {
+                "tabs": tab_info,
+                "current_tab": current_tab_index,
+                "total_tabs": len(tab_info),
+            }
+        except Exception as e:
+            logger.warning(
+                f"Failed to get tab info from session: {type(e).__name__}: {e}"
+            )
+
+            # Try to get actual tab count from session pages directly
+            try:
+                # Get the correct session instance for fallback
+                fallback_session = await self._get_session()
+
+                # Check browser session state
+                session_state = {
+                    "has_session": fallback_session is not None,
+                    "has_pages_attr": hasattr(fallback_session, '_pages'),
+                    "pages_count": len(fallback_session._pages)
+                    if hasattr(fallback_session, '_pages')
+                    else "unknown",
+                    "has_page": hasattr(fallback_session, '_page')
+                    and fallback_session._page is not None,
+                    "session_id": getattr(
+                        fallback_session, '_session_id', 'unknown'
+                    ),
+                }
+                logger.debug(f"Browser session state: {session_state}")
+
+                actual_tab_count = 0
+                if (
+                    hasattr(fallback_session, '_pages')
+                    and fallback_session._pages
+                ):
+                    actual_tab_count = len(fallback_session._pages)
+                    # Also try to filter out closed pages
+                    try:
+                        open_pages = [
+                            p
+                            for p in fallback_session._pages
+                            if not p.is_closed()
+                        ]
+                        actual_tab_count = len(open_pages)
+                        logger.debug(
+                            f"Found {actual_tab_count} open tabs out of "
+                            f"{len(fallback_session._pages)} total"
+                        )
+                    except Exception:
+                        # Keep the original count if we can't check page status
+                        pass
+
+                if actual_tab_count == 0:
+                    # If no pages, check if browser is even initialized
+                    if (
+                        hasattr(fallback_session, '_page')
+                        and fallback_session._page is not None
+                    ):
+                        actual_tab_count = 1
+                        logger.debug(
+                            "No pages in list but main page exists, assuming "
+                            "1 tab"
+                        )
+                    else:
+                        actual_tab_count = 1
+                        logger.debug("No pages found, defaulting to 1 tab")
+
+                logger.debug(f"Using fallback tab count: {actual_tab_count}")
+                return {
+                    "tabs": [],
+                    "current_tab": 0,
+                    "total_tabs": actual_tab_count,
+                }
+
+            except Exception as fallback_error:
+                logger.warning(
+                    f"Fallback tab count also failed: "
+                    f"{type(fallback_error).__name__}: {fallback_error}"
+                )
+                return {"tabs": [], "current_tab": 0, "total_tabs": 1}
+
     async def _exec_with_snapshot(
-        self, action: Dict[str, Any]
+        self,
+        action: Dict[str, Any],
+        element_details: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, str]:
         r"""Execute action and return result with snapshot comparison."""
 
@@ -379,72 +721,166 @@ class HybridBrowserToolkit(BaseToolkit):
         action_type = action.get("type", "unknown")
         logger.info(f"Executing action: {action_type}")
 
-        # Get before snapshot
-        logger.info("Capturing pre-action snapshot...")
-        snapshot_start = time.time()
-        before_snapshot = await self._session.get_snapshot(
-            force_refresh=True, diff_only=False
-        )
-        snapshot_time = time.time() - snapshot_start
-        logger.info(f"Pre-action snapshot captured in {snapshot_time:.2f}s")
+        action_start_time = time.time()
+        inputs: Dict[str, Any] = {"action": action}
+        page_load_time = None
 
-        # Execute action
-        logger.info(f"Executing {action_type} action...")
-        action_start = time.time()
-        result = await self._session.exec_action(action)
-        action_time = time.time() - action_start
-        logger.info(f"Action {action_type} completed in {action_time:.2f}s")
-
-        # Wait for page stability after action (especially important for click)
-        if action_type in ["click", "type", "select", "enter"]:
-            logger.info(
-                f"Waiting for page stability " f"after {action_type}..."
+        try:
+            # Get before snapshot
+            logger.info("Capturing pre-action snapshot...")
+            snapshot_start = time.time()
+            before_snapshot = await self._session.get_snapshot(
+                force_refresh=True, diff_only=False
             )
-            stability_start = time.time()
-            await self._wait_for_page_stability()
-            stability_time = time.time() - stability_start
+            snapshot_time = time.time() - snapshot_start
             logger.info(
-                f"Page stability wait " f"completed in {stability_time:.2f}s"
+                f"Pre-action snapshot captured in {snapshot_time:.2f}s"
             )
 
-        # Get after snapshot
-        logger.info("Capturing post-action snapshot...")
-        snapshot_start = time.time()
-        after_snapshot = await self._session.get_snapshot(
-            force_refresh=True, diff_only=False
-        )
-        snapshot_time = time.time() - snapshot_start
-        logger.info(
-            f"Post-action snapshot " f"captured in {snapshot_time:.2f}s"
-        )
-
-        # Check for snapshot quality and log warnings
-        if before_snapshot == after_snapshot:
-            snapshot = "snapshot not changed"
-            logger.debug("Page snapshot unchanged after action")
-        else:
-            snapshot = after_snapshot
-            # Check if snapshot is empty or problematic
-            if "<empty>" in after_snapshot:
-                logger.warning(
-                    f"Action {action_type} resulted "
-                    f"in empty snapshot - "
-                    f"page may still be loading"
+            # Execute action
+            logger.info(f"Executing {action_type} action...")
+            exec_start = time.time()
+            exec_result = await self._session.exec_action(action)
+            exec_time = time.time() - exec_start
+            logger.info(f"Action {action_type} completed in {exec_time:.2f}s")
+
+            # Parse the detailed result from ActionExecutor
+            if isinstance(exec_result, dict):
+                result_message = exec_result.get("message", str(exec_result))
+                action_details = exec_result.get("details", {})
+                success = exec_result.get("success", True)
+            else:
+                result_message = str(exec_result)
+                action_details = {}
+                success = True
+
+            # Wait for page stability after action (especially important for
+            # click)
+            stability_time: float = 0.0
+            if action_type in ["click", "type", "select", "enter"]:
+                logger.info(
+                    f"Waiting for page stability " f"after {action_type}..."
                 )
-            elif len(after_snapshot.strip()) < 50:
-                logger.warning(
-                    f"Action {action_type} resulted "
-                    f"in very short snapshot:"
-                    f" {len(after_snapshot)} chars"
+                stability_start = time.time()
+                await self._wait_for_page_stability()
+                stability_time = time.time() - stability_start
+                logger.info(
+                    f"Page stability wait "
+                    f"completed in "
+                    f"{stability_time:.2f}s"
                 )
+                page_load_time = stability_time
+
+                # Enhanced logging for page loading times
+                if self.enable_page_loading_logging and self.log_to_console:
+                    logger.info(
+                        f"[PAGE LOADING] Page stability for {action_type}: "
+                        f"{round(stability_time * 1000, 2)}ms"
+                    )
+
+            # Get after snapshot
+            logger.info("Capturing post-action snapshot...")
+            snapshot_start = time.time()
+            after_snapshot = await self._session.get_snapshot(
+                force_refresh=True, diff_only=False
+            )
+            snapshot_time = time.time() - snapshot_start
+            logger.info(
+                f"Post-action snapshot " f"captured in {snapshot_time:.2f}s"
+            )
+
+            # Check for snapshot quality and log warnings
+            if before_snapshot == after_snapshot:
+                snapshot = "snapshot not changed"
+                logger.debug("Page snapshot unchanged after action")
             else:
+                snapshot = after_snapshot
+                # Check if snapshot is empty or problematic
+                if "<empty>" in after_snapshot:
+                    logger.warning(
+                        f"Action {action_type} resulted "
+                        f"in empty snapshot - "
+                        f"page may still be loading"
+                    )
+                elif len(after_snapshot.strip()) < 50:
+                    logger.warning(
+                        f"Action {action_type} resulted "
+                        f"in very short snapshot:"
+                        f" {len(after_snapshot)} chars"
+                    )
+                else:
+                    logger.debug(
+                        f"Action {action_type} resulted "
+                        f"in updated snapshot: "
+                        f"{len(after_snapshot)} chars"
+                    )
+
+            # Get tab information for output
+            tab_info = await self._get_tab_info_for_output()
+
+            # Create comprehensive output for logging
+            execution_time = time.time() - action_start_time
+            outputs = {
+                "result": result_message,
+                "snapshot": snapshot,
+                "success": success,
+                "action_details": action_details,
+                "execution_stats": {
+                    "exec_time_ms": round(exec_time * 1000, 2),
+                    "stability_time_ms": round(stability_time * 1000, 2)
+                    if stability_time > 0
+                    else None,
+                    "total_time_ms": round(execution_time * 1000, 2),
+                },
+                **tab_info,  # Include tab information
+            }
+
+            # If snapshot is unchanged after click, add element details to log
+            if (
+                snapshot == "snapshot not changed"
+                and action_type == "click"
+                and element_details
+            ):
                 logger.debug(
-                    f"Action {action_type} resulted "
-                    f"in updated snapshot: "
-                    f"{len(after_snapshot)} chars"
+                    "Snapshot unchanged after click. "
+                    "Adding element details to log."
+                )
+                outputs["clicked_element_tag"] = element_details.get(
+                    "tagName", "N/A"
                 )
+                outputs["clicked_element_content"] = element_details.get(
+                    "name", ""
+                )
+                outputs["clicked_element_type"] = element_details.get(
+                    "role", "generic"
+                )
+
+            # Log the action with all details
+            await self._log_action(
+                action_name=f"_exec_with_snapshot_{action_type}",
+                inputs=inputs,
+                outputs=outputs,
+                execution_time=execution_time,
+                page_load_time=page_load_time,
+            )
+
+            return {"result": result_message, "snapshot": snapshot}
+
+        except Exception as e:
+            execution_time = time.time() - action_start_time
+            error_msg = f"{type(e).__name__}: {e!s}"
+
+            # Log error
+            await self._log_action(
+                action_name=f"_exec_with_snapshot_{action_type}",
+                inputs=inputs,
+                outputs=None,
+                execution_time=execution_time,
+                page_load_time=page_load_time,
+                error=error_msg,
+            )
 
-        return {"result": result, "snapshot": snapshot}
+            raise
 
     async def _extract_links_by_refs(
         self, snapshot: str, page, refs: List[str]
@@ -509,29 +945,31 @@ class HybridBrowserToolkit(BaseToolkit):
 
     # Public API Methods
 
-    async def open_browser(
-        self, start_url: Optional[str] = "https://search.brave.com/"
-    ) -> Dict[str, str]:
-        r"""Launches a new browser session, making it ready for web automation.
-
-        This method initializes the underlying browser instance. If a
-        `start_url` is provided, it will also navigate to that URL. If you
-        don't have a specific URL to start with, you can use a search engine
-        like 'https://search.brave.com/'.
+    async def open_browser(self) -> Dict[str, Any]:
+        r"""Launches a new browser session and navigates to the configured
+        default page.
 
-        Args:
-            start_url (Optional[str]): The initial URL to navigate to after the
-                browser is launched. If not provided, the browser will start
-                with a blank page. (default: :obj:`https://search.brave.com/`)
+        This method initializes the underlying browser instance and
+        automatically
+        navigates to the default start URL that was configured during toolkit
+        initialization. Agents cannot specify a custom URL - they must use the
+        visit_page tool for navigation to other URLs.
 
         Returns:
-            Dict[str, str]: A dictionary containing:
+            Dict[str, Any]: A dictionary containing:
                 - "result": A string confirming that the browser session has
-                  started.
+                  started and the default page has been loaded.
                 - "snapshot": A textual representation of the current page's
                   interactive elements. This snapshot is crucial for
                   identifying elements for subsequent actions.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
+        # Add logging if enabled
+        action_start = time.time()
+        inputs: Dict[str, Any] = {}  # No input parameters for agents
+
         logger.info("Starting browser session...")
 
         browser_start = time.time()
@@ -539,20 +977,42 @@ class HybridBrowserToolkit(BaseToolkit):
         browser_time = time.time() - browser_start
         logger.info(f"Browser session started in {browser_time:.2f}s")
 
-        if start_url:
-            logger.info(f"Auto-navigating to start URL: {start_url}")
-            return await self.visit_page(start_url)
+        try:
+            # Always use the configured default start URL
+            start_url = self.default_start_url
+            logger.info(f"Navigating to configured default page: {start_url}")
+
+            result = await self.visit_page(start_url)
+
+            # Log success
+            if self.enable_action_logging or self.enable_timing_logging:
+                execution_time = time.time() - action_start
+                await self._log_action(
+                    action_name="open_browser",
+                    inputs=inputs,
+                    outputs={
+                        "result": "Browser opened and navigated to default "
+                        "page."
+                    },
+                    execution_time=execution_time,
+                )
 
-        logger.info("Capturing initial browser snapshot...")
-        snapshot_start = time.time()
-        snapshot = await self._session.get_snapshot(
-            force_refresh=True, diff_only=False
-        )
-        snapshot_time = time.time() - snapshot_start
-        logger.info(f"Initial snapshot captured in {snapshot_time:.2f}s")
+            return result
 
-        return {"result": "Browser session started.", "snapshot": snapshot}
+        except Exception as e:
+            # Log error
+            if self.enable_action_logging or self.enable_timing_logging:
+                execution_time = time.time() - action_start
+                await self._log_action(
+                    action_name="open_browser",
+                    inputs=inputs,
+                    outputs=None,
+                    execution_time=execution_time,
+                    error=f"{type(e).__name__}: {e!s}",
+                )
+            raise
 
+    @action_logger
     async def close_browser(self) -> str:
         r"""Closes the current browser session and releases all associated
         resources.
@@ -573,7 +1033,8 @@ class HybridBrowserToolkit(BaseToolkit):
         await self._session.close()
         return "Browser session closed."
 
-    async def visit_page(self, url: str) -> Dict[str, str]:
+    @action_logger
+    async def visit_page(self, url: str) -> Dict[str, Any]:
         r"""Navigates the current browser page to a specified URL.
 
         Args:
@@ -581,16 +1042,22 @@ class HybridBrowserToolkit(BaseToolkit):
                 valid URL.
 
         Returns:
-            Dict[str, str]: A dictionary containing:
+            Dict[str, Any]: A dictionary containing:
                 - "result": A message indicating the outcome of the navigation,
                   e.g., "Navigation successful.".
                 - "snapshot": A new textual snapshot of the page's interactive
                   elements after the new page has loaded.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
         if not url or not isinstance(url, str):
             return {
                 "result": "Error: 'url' must be a non-empty string",
                 "snapshot": "",
+                "tabs": [],
+                "current_tab": 0,
+                "total_tabs": 1,
             }
 
         if '://' not in url:
@@ -613,8 +1080,142 @@ class HybridBrowserToolkit(BaseToolkit):
         snapshot_time = time.time() - snapshot_start
         logger.info(f"Navigation snapshot captured in {snapshot_time:.2f}s")
 
-        return {"result": nav_result, "snapshot": snapshot}
+        # Get tab information
+        tab_info = await self._get_tab_info_for_output()
+
+        return {"result": nav_result, "snapshot": snapshot, **tab_info}
+
+    @action_logger
+    async def back(self) -> Dict[str, Any]:
+        r"""Navigates the browser back to the previous page in history.
+
+        This function simulates clicking the browser's back button, taking
+        you to the previously visited page if one exists in the browser
+        history.
 
+        Returns:
+            Dict[str, Any]: A dictionary containing:
+                - "result": A message indicating the outcome of the back
+                  navigation, e.g., "Back navigation successful." or an error
+                  message if no previous page exists.
+                - "snapshot": A new textual snapshot of the page after
+                  navigation. If the snapshot is unchanged, it will be the
+                  string "snapshot not changed".
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
+        """
+        page = await self._require_page()
+
+        try:
+            logger.info("Navigating back in browser history...")
+            nav_start = time.time()
+            await page.go_back(wait_until="domcontentloaded", timeout=30000)
+            nav_time = time.time() - nav_start
+            logger.info(f"Back navigation completed in {nav_time:.2f}s")
+
+            # Wait for page stability
+            await self._wait_for_page_stability()
+
+            # Get snapshot
+            logger.info("Capturing page snapshot after back navigation...")
+            snapshot_start = time.time()
+            snapshot = await self._session.get_snapshot(
+                force_refresh=True, diff_only=False
+            )
+            snapshot_time = time.time() - snapshot_start
+            logger.info(
+                f"Back navigation snapshot captured in {snapshot_time:.2f}s"
+            )
+
+            # Get tab information
+            tab_info = await self._get_tab_info_for_output()
+
+            return {
+                "result": "Back navigation successful.",
+                "snapshot": snapshot,
+                **tab_info,
+            }
+
+        except Exception as e:
+            logger.warning(f"Back navigation failed: {e}")
+            # Get current snapshot even if navigation failed
+            snapshot = await self._session.get_snapshot(
+                force_refresh=True, diff_only=False
+            )
+            tab_info = await self._get_tab_info_for_output()
+            return {
+                "result": f"Back navigation failed: {e!s}",
+                "snapshot": snapshot,
+                **tab_info,
+            }
+
+    @action_logger
+    async def forward(self) -> Dict[str, Any]:
+        r"""Navigates the browser forward to the next page in history.
+
+        This function simulates clicking the browser's forward button, taking
+        you to the next page in the browser history if one exists (i.e.,
+        if you have previously navigated back).
+
+        Returns:
+            Dict[str, Any]: A dictionary containing:
+                - "result": A message indicating the outcome of the forward
+                  navigation, e.g., "Forward navigation successful." or an
+                  error message if no next page exists.
+                - "snapshot": A new textual snapshot of the page after
+                  navigation. If the snapshot is unchanged, it will be the
+                  string "snapshot not changed".
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
+        """
+        page = await self._require_page()
+
+        try:
+            logger.info("Navigating forward in browser history...")
+            nav_start = time.time()
+            await page.go_forward(wait_until="domcontentloaded", timeout=30000)
+            nav_time = time.time() - nav_start
+            logger.info(f"Forward navigation completed in {nav_time:.2f}s")
+
+            # Wait for page stability
+            await self._wait_for_page_stability()
+
+            # Get snapshot
+            logger.info("Capturing page snapshot after forward navigation...")
+            snapshot_start = time.time()
+            snapshot = await self._session.get_snapshot(
+                force_refresh=True, diff_only=False
+            )
+            snapshot_time = time.time() - snapshot_start
+            logger.info(
+                f"Forward navigation snapshot captured in {snapshot_time:.2f}s"
+            )
+
+            # Get tab information
+            tab_info = await self._get_tab_info_for_output()
+
+            return {
+                "result": "Forward navigation successful.",
+                "snapshot": snapshot,
+                **tab_info,
+            }
+
+        except Exception as e:
+            logger.warning(f"Forward navigation failed: {e}")
+            # Get current snapshot even if navigation failed
+            snapshot = await self._session.get_snapshot(
+                force_refresh=True, diff_only=False
+            )
+            tab_info = await self._get_tab_info_for_output()
+            return {
+                "result": f"Forward navigation failed: {e!s}",
+                "snapshot": snapshot,
+                **tab_info,
+            }
+
+    @action_logger
     async def get_page_snapshot(self) -> str:
         r"""Captures a textual representation of the current page's content.
 
@@ -650,6 +1251,7 @@ class HybridBrowserToolkit(BaseToolkit):
         )
 
     @dependencies_required('PIL')
+    @action_logger
     async def get_som_screenshot(self):
         r"""Captures a screenshot of the current webpage and visually marks all
         interactive elements. "SoM" stands for "Set of Marks".
@@ -733,7 +1335,7 @@ class HybridBrowserToolkit(BaseToolkit):
 
         return ToolResult(text=text_result, images=[img_data_url])
 
-    async def click(self, *, ref: str) -> Dict[str, str]:
+    async def click(self, *, ref: str) -> Dict[str, Any]:
         r"""Clicks on an interactive element on the page.
 
         Args:
@@ -742,12 +1344,15 @@ class HybridBrowserToolkit(BaseToolkit):
                 `get_som_screenshot`).
 
         Returns:
-            Dict[str, str]: A dictionary containing:
+            Dict[str, Any]: A dictionary containing:
                 - "result": A message confirming the click action.
                 - "snapshot": A new textual snapshot of the page after the
                   click, which may have changed as a result of the action. If
                   the snapshot is unchanged, it will be the string "snapshot
                   not changed".
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
         self._validate_ref(ref, "click")
 
@@ -755,19 +1360,30 @@ class HybridBrowserToolkit(BaseToolkit):
         elements = analysis.get("elements", {})
         if ref not in elements:
             available_refs = list(elements.keys())
-            logger.error(
-                f"Error: Element reference '{ref}' not found. "
-                f"Available refs: {available_refs}"
-            )
+            logger.error(f"Error: Element reference '{ref}' not found. ")
+            # Added snapshot to give more context on failure
+            snapshot = self._format_snapshot_from_analysis(analysis)
+            tab_info = await self._get_tab_info_for_output()
             return {
                 "result": f"Error: Element reference '{ref}' not found. "
-                f"Available refs: {available_refs}"
+                f"Available refs: {available_refs}",
+                "snapshot": snapshot,
+                **tab_info,
             }
 
+        element_details = elements.get(ref)
         action = {"type": "click", "ref": ref}
-        return await self._exec_with_snapshot(action)
+        result = await self._exec_with_snapshot(
+            action, element_details=element_details
+        )
+
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
 
-    async def type(self, *, ref: str, text: str) -> Dict[str, str]:
+        return result
+
+    async def type(self, *, ref: str, text: str) -> Dict[str, Any]:
         r"""Types text into an input field, such as a textbox or search bar.
 
         Args:
@@ -775,18 +1391,27 @@ class HybridBrowserToolkit(BaseToolkit):
             text (str): The text to be typed into the element.
 
         Returns:
-            Dict[str, str]: A dictionary containing:
+            Dict[str, Any]: A dictionary containing:
                 - "result": A message confirming the type action.
                 - "snapshot": A new textual snapshot of the page after the
                   text has been entered.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
         self._validate_ref(ref, "type")
         await self._get_unified_analysis()  # Ensure aria-ref attributes
 
         action = {"type": "type", "ref": ref, "text": text}
-        return await self._exec_with_snapshot(action)
+        result = await self._exec_with_snapshot(action)
+
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
+
+        return result
 
-    async def select(self, *, ref: str, value: str) -> Dict[str, str]:
+    async def select(self, *, ref: str, value: str) -> Dict[str, Any]:
         r"""Selects an option from a dropdown (`<select>`) element.
 
         Args:
@@ -796,17 +1421,26 @@ class HybridBrowserToolkit(BaseToolkit):
                 visible text.
 
         Returns:
-            Dict[str, str]: A dictionary containing:
+            Dict[str, Any]: A dictionary containing:
                 - "result": A message confirming the select action.
                 - "snapshot": A new snapshot of the page after the selection.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
         self._validate_ref(ref, "select")
         await self._get_unified_analysis()
 
         action = {"type": "select", "ref": ref, "value": value}
-        return await self._exec_with_snapshot(action)
+        result = await self._exec_with_snapshot(action)
+
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
 
-    async def scroll(self, *, direction: str, amount: int) -> Dict[str, str]:
+        return result
+
+    async def scroll(self, *, direction: str, amount: int) -> Dict[str, Any]:
         r"""Scrolls the page window up or down by a specified amount.
 
         Args:
@@ -815,40 +1449,68 @@ class HybridBrowserToolkit(BaseToolkit):
             amount (int): The number of pixels to scroll.
 
         Returns:
-            Dict[str, str]: A dictionary containing:
+            Dict[str, Any]: A dictionary containing:
                 - "result": A confirmation of the scroll action.
                 - "snapshot": A new snapshot of the page after scrolling.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
         if direction not in ("up", "down"):
+            tab_info = await self._get_tab_info_for_output()
             return {
                 "result": "Error: direction must be 'up' or 'down'",
                 "snapshot": "",
+                **tab_info,
             }
 
         action = {"type": "scroll", "direction": direction, "amount": amount}
-        return await self._exec_with_snapshot(action)
+        result = await self._exec_with_snapshot(action)
 
-    async def enter(self, *, ref: str) -> Dict[str, str]:
-        r"""Simulates pressing the Enter key on a specific element.
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
 
-        This is often used to submit forms after filling them out.
+        return result
 
-        Args:
-            ref (str): The reference ID of the element to press Enter on.
+    async def enter(self) -> Dict[str, Any]:
+        r"""Simulates pressing the Enter key on the currently focused element.
+
+        This tool is used to execute or confirm an action after interacting
+        with
+        an element, such as:
+        - Submitting a search query after typing in a search box.
+        - Confirming a form submission.
+        - Executing a command in a text input field.
+
+        The common usage pattern is to first use the 'type' tool to input
+        text, which sets the focus, and then call 'enter' without any
+        parameters to trigger the action.
 
         Returns:
-            Dict[str, str]: A dictionary containing:
-                - "result": A confirmation of the action.
+            Dict[str, Any]: A dictionary containing:
+                - "result": A confirmation of the Enter key action.
                 - "snapshot": A new page snapshot, as this action often
                   triggers navigation or page updates.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
-        self._validate_ref(ref, "enter")
-        action = {"type": "enter", "ref": ref}
-        return await self._exec_with_snapshot(action)
+        # Always press Enter on the currently focused element
+        action = {"type": "enter"}
+
+        result = await self._exec_with_snapshot(action)
+
+        # Add tab information to the result
+        tab_info = await self._get_tab_info_for_output()
+        result.update(tab_info)
+
+        return result
 
+    @action_logger
     async def wait_user(
         self, timeout_sec: Optional[float] = None
-    ) -> Dict[str, str]:
+    ) -> Dict[str, Any]:
         r"""Pauses the agent's execution and waits for human intervention.
 
         This is useful for tasks that require manual steps, like solving a
@@ -861,10 +1523,13 @@ class HybridBrowserToolkit(BaseToolkit):
                 automatically. If `None`, it will wait indefinitely.
 
         Returns:
-            Dict[str, str]: A dictionary containing:
+            Dict[str, Any]: A dictionary containing:
                 - "result": A message indicating how the wait ended (e.g.,
                   "User resumed." or "Timeout... reached, auto-resumed.").
                 - "snapshot": The current page snapshot after the wait.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
         """
         import asyncio
 
@@ -905,8 +1570,11 @@ class HybridBrowserToolkit(BaseToolkit):
         snapshot = await self._session.get_snapshot(
             force_refresh=True, diff_only=False
         )
-        return {"result": result_msg, "snapshot": snapshot}
+        tab_info = await self._get_tab_info_for_output()
+
+        return {"result": result_msg, "snapshot": snapshot, **tab_info}
 
+    @action_logger
     async def get_page_links(self, *, ref: List[str]) -> Dict[str, Any]:
         r"""Retrieves the full URLs for a given list of link reference IDs.
 
@@ -938,6 +1606,7 @@ class HybridBrowserToolkit(BaseToolkit):
 
         return {"links": links}
 
+    @action_logger
     async def solve_task(
         self, task_prompt: str, start_url: str, max_steps: int = 15
     ) -> str:
@@ -967,6 +1636,48 @@ class HybridBrowserToolkit(BaseToolkit):
         await agent.process_command(task_prompt, max_steps=max_steps)
         return "Task processing finished - see stdout for detailed trace."
 
+    def get_log_summary(self) -> Dict[str, Any]:
+        r"""Get a summary of logged actions."""
+        if not self.log_buffer:
+            return {"total_actions": 0, "summary": "No actions logged"}
+
+        total_actions = len(self.log_buffer)
+        total_execution_time = sum(
+            entry.get("execution_time_ms", 0) for entry in self.log_buffer
+        )
+        total_page_load_time = sum(
+            entry.get("page_load_time_ms", 0)
+            for entry in self.log_buffer
+            if "page_load_time_ms" in entry
+        )
+
+        action_counts: Dict[str, int] = {}
+        error_count = 0
+
+        for entry in self.log_buffer:
+            action = entry["action"]
+            action_counts[action] = action_counts.get(action, 0) + 1
+            if "error" in entry:
+                error_count += 1
+
+        return {
+            "total_actions": total_actions,
+            "total_execution_time_ms": round(total_execution_time, 2),
+            "total_page_load_time_ms": round(total_page_load_time, 2),
+            "action_counts": action_counts,
+            "error_count": error_count,
+            "success_rate": round(
+                (total_actions - error_count) / total_actions * 100, 2
+            )
+            if total_actions > 0
+            else 0,
+        }
+
+    def clear_logs(self) -> None:
+        r"""Clear the log buffer."""
+        self.log_buffer.clear()
+        logger.info("Log buffer cleared")
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Get available function tools
         based on enabled_tools configuration."""
@@ -975,6 +1686,8 @@ class HybridBrowserToolkit(BaseToolkit):
             "open_browser": self.open_browser,
             "close_browser": self.close_browser,
             "visit_page": self.visit_page,
+            "back": self.back,
+            "forward": self.forward,
             "get_page_snapshot": self.get_page_snapshot,
             "get_som_screenshot": self.get_som_screenshot,
             "get_page_links": self.get_page_links,
@@ -985,6 +1698,9 @@ class HybridBrowserToolkit(BaseToolkit):
             "enter": self.enter,
             "wait_user": self.wait_user,
             "solve_task": self.solve_task,
+            "switch_tab": self.switch_tab,
+            "close_tab": self.close_tab,
+            "get_tab_info": self.get_tab_info,
         }
 
         enabled_tools = []
@@ -998,11 +1714,165 @@ class HybridBrowserToolkit(BaseToolkit):
                 continue
 
             if tool_name in tool_map:
-                enabled_tools.append(
-                    FunctionTool(cast(Callable, tool_map[tool_name]))
+                tool = FunctionTool(
+                    cast(Callable[..., Any], tool_map[tool_name])
                 )
+                enabled_tools.append(tool)
             else:
                 logger.warning(f"Unknown tool name: {tool_name}")
 
         logger.info(f"Returning {len(enabled_tools)} enabled tools")
         return enabled_tools
+
+    def clone_for_new_session(
+        self, new_session_id: Optional[str] = None
+    ) -> "HybridBrowserToolkit":
+        r"""Create a new instance of HybridBrowserToolkit with a unique
+        session.
+
+        Args:
+            new_session_id: Optional new session ID. If None, a UUID will be
+            generated.
+
+        Returns:
+            A new HybridBrowserToolkit instance with the same configuration
+            but a different session.
+        """
+        import uuid
+
+        if new_session_id is None:
+            new_session_id = str(uuid.uuid4())[:8]
+
+        return HybridBrowserToolkit(
+            headless=self._headless,
+            user_data_dir=self._user_data_dir,
+            stealth=self._session._stealth if self._session else False,
+            web_agent_model=self.web_agent_model,
+            cache_dir=f"{self.cache_dir.rstrip('/')}_clone_{new_session_id}/",
+            enabled_tools=self.enabled_tools.copy(),
+            browser_log_to_file=self.log_to_file,
+            session_id=new_session_id,
+            default_start_url=self.default_start_url,
+        )
+
+    @action_logger
+    async def switch_tab(self, *, tab_index: int) -> Dict[str, Any]:
+        r"""Switches to a specific browser tab by its index.
+
+        This allows you to control which tab is currently active. After
+        switching, all subsequent browser actions will operate on the newly
+        selected tab.
+
+        Args:
+            tab_index (int): The zero-based index of the tab to switch to.
+                Use `get_tab_info` to see available tabs and their indices.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing:
+                - "result": A message indicating success or failure of the
+                  tab switch.
+                - "snapshot": A textual snapshot of the newly active tab's
+                  content.
+                - "tabs": List of all open tabs with their information.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of open tabs.
+        """
+        await self._ensure_browser()
+        session = await self._get_session()
+
+        success = await session.switch_to_tab(tab_index)
+
+        if success:
+            snapshot = await session.get_snapshot(
+                force_refresh=True, diff_only=False
+            )
+            tab_info = await self._get_tab_info_for_output()
+
+            result = {
+                "result": f"Successfully switched to tab {tab_index}",
+                "snapshot": snapshot,
+                **tab_info,
+            }
+        else:
+            tab_info = await self._get_tab_info_for_output()
+            result = {
+                "result": f"Failed to switch to tab {tab_index}. Tab may not "
+                f"exist.",
+                "snapshot": "",
+                **tab_info,
+            }
+
+        return result
+
+    @action_logger
+    async def close_tab(self, *, tab_index: int) -> Dict[str, Any]:
+        r"""Closes a specific browser tab by its index.
+
+        After closing a tab, the browser will automatically switch to another
+        available tab. If the closed tab was the only one open, the browser
+        session will remain active but without any pages.
+
+        Args:
+            tab_index (int): The zero-based index of the tab to close.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing:
+                - "result": A message indicating success or failure of the
+                  tab closure.
+                - "snapshot": A textual snapshot of the currently active tab
+                  after the closure (empty if no tabs remain).
+                - "tabs": List of remaining open tabs.
+                - "current_tab": Index of the currently active tab.
+                - "total_tabs": Total number of remaining open tabs.
+        """
+        await self._ensure_browser()
+        session = await self._get_session()
+
+        success = await session.close_tab(tab_index)
+
+        if success:
+            # Get current state after closing the tab
+            try:
+                snapshot = await session.get_snapshot(
+                    force_refresh=True, diff_only=False
+                )
+            except Exception:
+                snapshot = ""  # No active tab
+
+            tab_info = await self._get_tab_info_for_output()
+
+            result = {
+                "result": f"Successfully closed tab {tab_index}",
+                "snapshot": snapshot,
+                **tab_info,
+            }
+        else:
+            tab_info = await self._get_tab_info_for_output()
+            result = {
+                "result": f"Failed to close tab {tab_index}. Tab may not "
+                f"exist.",
+                "snapshot": "",
+                **tab_info,
+            }
+
+        return result
+
+    @action_logger
+    async def get_tab_info(self) -> Dict[str, Any]:
+        r"""Retrieves information about all currently open browser tabs.
+
+        This provides a comprehensive overview of the browser state, including
+        all open tabs, their titles, URLs, and which one is currently active.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing:
+                - "tabs": A list of dictionaries, each representing a tab with:
+                  - "index": The zero-based index of the tab
+                  - "title": The page title
+                  - "url": The current URL
+                  - "is_current": Whether this is the currently active tab
+                - "current_tab": Index of the currently active tab
+                - "total_tabs": Total number of open tabs
+        """
+        await self._ensure_browser()
+        return await self._get_tab_info_for_output()