openhands-tools 1.7.0__tar.gz → 1.7.2__tar.gz

{openhands_tools-1.7.0 → openhands_tools-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.7.0
+Version: 1.7.2
 Summary: OpenHands Tools - Runtime tools for AI agents
 Requires-Python: >=3.12
 Requires-Dist: openhands-sdk

{openhands_tools-1.7.0 → openhands_tools-1.7.2}/openhands/tools/browser_use/__init__.py

@@ -9,6 +9,8 @@ from openhands.tools.browser_use.definition import (
     BrowserGetContentTool,
     BrowserGetStateAction,
     BrowserGetStateTool,
+    BrowserGetStorageAction,
+    BrowserGetStorageTool,
     BrowserGoBackAction,
     BrowserGoBackTool,
     BrowserListTabsAction,
@@ -18,6 +20,8 @@ from openhands.tools.browser_use.definition import (
     BrowserObservation,
     BrowserScrollAction,
     BrowserScrollTool,
+    BrowserSetStorageAction,
+    BrowserSetStorageTool,
     BrowserSwitchTabAction,
     BrowserSwitchTabTool,
     BrowserToolSet,
@@ -38,6 +42,8 @@ __all__ = [
     "BrowserListTabsTool",
     "BrowserSwitchTabTool",
     "BrowserCloseTabTool",
+    "BrowserGetStorageTool",
+    "BrowserSetStorageTool",
     # Actions
     "BrowserNavigateAction",
     "BrowserClickAction",
@@ -49,6 +55,8 @@ __all__ = [
     "BrowserListTabsAction",
     "BrowserSwitchTabAction",
     "BrowserCloseTabAction",
+    "BrowserGetStorageAction",
+    "BrowserSetStorageAction",
     # Observations
     "BrowserObservation",
     "BrowserToolSet",

{openhands_tools-1.7.0 → openhands_tools-1.7.2}/openhands/tools/browser_use/definition.py

@@ -1,6 +1,9 @@
 """Browser-use tool implementation for web automation."""
 
+import base64
+import hashlib
 from collections.abc import Sequence
+from pathlib import Path
 from typing import TYPE_CHECKING, Literal, Self
 
 from pydantic import Field
@@ -57,6 +60,29 @@ class BrowserObservation(Observation):
         description="Directory where full output files are saved",
     )
 
+    def _save_screenshot(self, base64_data: str, save_dir: str) -> str | None:
+        try:
+            save_dir_path = Path(save_dir)
+            save_dir_path.mkdir(parents=True, exist_ok=True)
+
+            mime_type = detect_image_mime_type(base64_data)
+            ext = mime_type.split("/")[-1]
+            if ext == "jpeg":
+                ext = "jpg"
+
+            # Generate hash for filename
+            content_hash = hashlib.sha256(base64_data.encode("utf-8")).hexdigest()[:8]
+            filename = f"browser_screenshot_{content_hash}.{ext}"
+            file_path = save_dir_path / filename
+
+            if not file_path.exists():
+                image_data = base64.b64decode(base64_data)
+                file_path.write_bytes(image_data)
+
+            return str(file_path)
+        except Exception:
+            return None
+
     @property
     def to_llm_content(self) -> Sequence[TextContent | ImageContent]:
         llm_content: list[TextContent | ImageContent] = []
@@ -81,6 +107,17 @@ class BrowserObservation(Observation):
 
         if self.screenshot_data:
             mime_type = detect_image_mime_type(self.screenshot_data)
+
+            # Save screenshot if directory is available
+            if self.full_output_save_dir:
+                saved_path = self._save_screenshot(
+                    self.screenshot_data, self.full_output_save_dir
+                )
+                if saved_path:
+                    llm_content.append(
+                        TextContent(text=f"Screenshot saved to: {saved_path}")
+                    )
+
             # Convert base64 to data URL format for ImageContent
             data_url = f"data:{mime_type};base64,{self.screenshot_data}"
             llm_content.append(ImageContent(image_urls=[data_url]))
@@ -542,6 +579,95 @@ class BrowserCloseTabTool(ToolDefinition[BrowserCloseTabAction, BrowserObservati
         ]
 
 
+# ============================================
+# `browser_get_storage`
+# ============================================
+class BrowserGetStorageAction(BrowserAction):
+    """Schema for getting browser storage (cookies, local storage, session storage)."""
+
+    pass
+
+
+BROWSER_GET_STORAGE_DESCRIPTION = """Get browser storage data including cookies,
+local storage, and session storage.
+
+This tool extracts all cookies and storage data from the current browser session.
+Useful for debugging, session management, or extracting authentication tokens.
+"""
+
+
+class BrowserGetStorageTool(
+    ToolDefinition[BrowserGetStorageAction, BrowserObservation]
+):
+    """Tool for getting browser storage."""
+
+    @classmethod
+    def create(cls, executor: "BrowserToolExecutor") -> Sequence[Self]:
+        return [
+            cls(
+                description=BROWSER_GET_STORAGE_DESCRIPTION,
+                action_type=BrowserGetStorageAction,
+                observation_type=BrowserObservation,
+                annotations=ToolAnnotations(
+                    title="browser_get_storage",
+                    readOnlyHint=True,
+                    destructiveHint=False,
+                    idempotentHint=True,
+                    openWorldHint=False,
+                ),
+                executor=executor,
+            )
+        ]
+
+
+# ============================================
+# `browser_set_storage`
+# ============================================
+class BrowserSetStorageAction(BrowserAction):
+    """Schema for setting browser storage (cookies, local storage, session storage)."""
+
+    storage_state: dict = Field(
+        description="Storage state dictionary containing 'cookies' and 'origins' (from browser_get_storage)"  # noqa: E501
+    )
+
+
+BROWSER_SET_STORAGE_DESCRIPTION = """Set browser storage data including cookies,
+local storage, and session storage.
+
+This tool allows you to restore or set the browser's storage state. You can use the
+output from browser_get_storage to restore a previous session.
+
+Parameters:
+- storage_state: A dictionary containing 'cookies' and 'origins'.
+  - cookies: List of cookie objects
+  - origins: List of origin objects containing 'localStorage' and 'sessionStorage'
+"""
+
+
+class BrowserSetStorageTool(
+    ToolDefinition[BrowserSetStorageAction, BrowserObservation]
+):
+    """Tool for setting browser storage."""
+
+    @classmethod
+    def create(cls, executor: "BrowserToolExecutor") -> Sequence[Self]:
+        return [
+            cls(
+                description=BROWSER_SET_STORAGE_DESCRIPTION,
+                action_type=BrowserSetStorageAction,
+                observation_type=BrowserObservation,
+                annotations=ToolAnnotations(
+                    title="browser_set_storage",
+                    readOnlyHint=False,
+                    destructiveHint=True,
+                    idempotentHint=False,
+                    openWorldHint=False,
+                ),
+                executor=executor,
+            )
+        ]
+
+
 class BrowserToolSet(ToolDefinition[BrowserAction, BrowserObservation]):
     """A set of all browser tools.
 
@@ -593,6 +719,8 @@ class BrowserToolSet(ToolDefinition[BrowserAction, BrowserObservation]):
             BrowserListTabsTool,
             BrowserSwitchTabTool,
             BrowserCloseTabTool,
+            BrowserGetStorageTool,
+            BrowserSetStorageTool,
         ]:
             tools.extend(tool_class.create(executor))
         return tools

{openhands_tools-1.7.0 → openhands_tools-1.7.2}/openhands/tools/browser_use/impl.py

@@ -214,11 +214,13 @@ class BrowserToolExecutor(ToolExecutor[BrowserAction, BrowserObservation]):
             BrowserCloseTabAction,
             BrowserGetContentAction,
             BrowserGetStateAction,
+            BrowserGetStorageAction,
             BrowserGoBackAction,
             BrowserListTabsAction,
             BrowserNavigateAction,
             BrowserObservation,
             BrowserScrollAction,
+            BrowserSetStorageAction,
             BrowserSwitchTabAction,
             BrowserTypeAction,
         )
@@ -234,6 +236,10 @@ class BrowserToolExecutor(ToolExecutor[BrowserAction, BrowserObservation]):
                 result = await self.type_text(action.index, action.text)
             elif isinstance(action, BrowserGetStateAction):
                 return await self.get_state(action.include_screenshot)
+            elif isinstance(action, BrowserGetStorageAction):
+                result = await self.get_storage()
+            elif isinstance(action, BrowserSetStorageAction):
+                result = await self.set_storage(action.storage_state)
             elif isinstance(action, BrowserGetContentAction):
                 result = await self.get_content(
                     action.extract_links, action.start_from_char
@@ -334,6 +340,16 @@ class BrowserToolExecutor(ToolExecutor[BrowserAction, BrowserObservation]):
             full_output_save_dir=self.full_output_save_dir,
         )
 
+    async def get_storage(self) -> str:
+        """Get browser storage (cookies, local storage, session storage)."""
+        await self._ensure_initialized()
+        return await self._server._get_storage()
+
+    async def set_storage(self, storage_state: dict) -> str:
+        """Set browser storage (cookies, local storage, session storage)."""
+        await self._ensure_initialized()
+        return await self._server._set_storage(storage_state)
+
     # Tab Management
     async def list_tabs(self) -> str:
         """List all open tabs."""

openhands_tools-1.7.2/openhands/tools/browser_use/server.py

@@ -0,0 +1,190 @@
+from browser_use.dom.markdown_extractor import extract_clean_markdown
+
+from openhands.sdk import get_logger
+from openhands.tools.browser_use.logging_fix import LogSafeBrowserUseServer
+
+
+logger = get_logger(__name__)
+
+
+class CustomBrowserUseServer(LogSafeBrowserUseServer):
+    """
+    Custom BrowserUseServer with a new tool for extracting web
+    page's content in markdown.
+    """
+
+    async def _get_storage(self) -> str:
+        """Get browser storage (cookies, local storage, session storage)."""
+        import json
+
+        if not self.browser_session:
+            return "Error: No browser session active"
+
+        try:
+            # Use the private method from BrowserSession to get storage state
+            # This returns a dict with 'cookies' and 'origins'
+            # (localStorage/sessionStorage)
+            storage_state = await self.browser_session._cdp_get_storage_state()
+            return json.dumps(storage_state, indent=2)
+        except Exception as e:
+            logger.exception("Error getting storage state", exc_info=e)
+            return f"Error getting storage state: {str(e)}"
+
+    async def _set_storage(self, storage_state: dict) -> str:
+        """Set browser storage (cookies, local storage, session storage)."""
+        if not self.browser_session:
+            return "Error: No browser session active"
+
+        try:
+            # 1. Set cookies
+            cookies = storage_state.get("cookies", [])
+            if cookies:
+                await self.browser_session._cdp_set_cookies(cookies)
+
+            # 2. Set local/session storage
+            origins = storage_state.get("origins", [])
+            if origins:
+                cdp_session = await self.browser_session.get_or_create_cdp_session()
+
+                # Enable DOMStorage
+                await cdp_session.cdp_client.send.DOMStorage.enable(
+                    session_id=cdp_session.session_id
+                )
+
+                try:
+                    for origin_data in origins:
+                        origin = origin_data.get("origin")
+                        if not origin:
+                            continue
+
+                        dom_storage = cdp_session.cdp_client.send.DOMStorage
+
+                        # Set localStorage
+                        for item in origin_data.get("localStorage", []):
+                            key = item.get("key") or item.get("name")
+                            if not key:
+                                continue
+                            await dom_storage.setDOMStorageItem(
+                                params={
+                                    "storageId": {
+                                        "securityOrigin": origin,
+                                        "isLocalStorage": True,
+                                    },
+                                    "key": key,
+                                    "value": item["value"],
+                                },
+                                session_id=cdp_session.session_id,
+                            )
+
+                        # Set sessionStorage
+                        for item in origin_data.get("sessionStorage", []):
+                            key = item.get("key") or item.get("name")
+                            if not key:
+                                continue
+                            await dom_storage.setDOMStorageItem(
+                                params={
+                                    "storageId": {
+                                        "securityOrigin": origin,
+                                        "isLocalStorage": False,
+                                    },
+                                    "key": key,
+                                    "value": item["value"],
+                                },
+                                session_id=cdp_session.session_id,
+                            )
+                finally:
+                    # Disable DOMStorage
+                    await cdp_session.cdp_client.send.DOMStorage.disable(
+                        session_id=cdp_session.session_id
+                    )
+
+            return "Storage set successfully"
+        except Exception as e:
+            logger.exception("Error setting storage state", exc_info=e)
+            return f"Error setting storage state: {str(e)}"
+
+    async def _get_content(self, extract_links=False, start_from_char: int = 0) -> str:
+        MAX_CHAR_LIMIT = 30000
+
+        if not self.browser_session:
+            return "Error: No browser session active"
+
+        # Extract clean markdown using the new method
+        try:
+            content, content_stats = await extract_clean_markdown(
+                browser_session=self.browser_session, extract_links=extract_links
+            )
+        except Exception as e:
+            logger.exception(
+                "Error extracting clean markdown", exc_info=e, stack_info=True
+            )
+            return f"Could not extract clean markdown: {type(e).__name__}"
+
+        # Original content length for processing
+        final_filtered_length = content_stats["final_filtered_chars"]
+
+        if start_from_char > 0:
+            if start_from_char >= len(content):
+                return f"start_from_char ({start_from_char}) exceeds content length ({len(content)}). Content has {final_filtered_length} characters after filtering."  # noqa: E501
+
+            content = content[start_from_char:]
+            content_stats["started_from_char"] = start_from_char
+
+        # Smart truncation with context preservation
+        truncated = False
+        if len(content) > MAX_CHAR_LIMIT:
+            # Try to truncate at a natural break point (paragraph, sentence)
+            truncate_at = MAX_CHAR_LIMIT
+
+            # Look for paragraph break within last 500 chars of limit
+            paragraph_break = content.rfind(
+                "\n\n", MAX_CHAR_LIMIT - 500, MAX_CHAR_LIMIT
+            )
+            if paragraph_break > 0:
+                truncate_at = paragraph_break
+            else:
+                # Look for sentence break within last 200 chars of limit
+                sentence_break = content.rfind(
+                    ".", MAX_CHAR_LIMIT - 200, MAX_CHAR_LIMIT
+                )
+                if sentence_break > 0:
+                    truncate_at = sentence_break + 1
+
+            content = content[:truncate_at]
+            truncated = True
+            next_start = (start_from_char or 0) + truncate_at
+            content_stats["truncated_at_char"] = truncate_at
+            content_stats["next_start_char"] = next_start
+
+        # Add content statistics to the result
+        original_html_length = content_stats["original_html_chars"]
+        initial_markdown_length = content_stats["initial_markdown_chars"]
+        chars_filtered = content_stats["filtered_chars_removed"]
+
+        stats_summary = (
+            f"Content processed: {original_html_length:,}"
+            + f" HTML chars → {initial_markdown_length:,}"
+            + f" initial markdown → {final_filtered_length:,} filtered markdown"
+        )
+        if start_from_char > 0:
+            stats_summary += f" (started from char {start_from_char:,})"
+        if truncated:
+            stats_summary += f" → {len(content):,} final chars (truncated, use start_from_char={content_stats['next_start_char']} to continue)"  # noqa: E501
+        elif chars_filtered > 0:
+            stats_summary += f" (filtered {chars_filtered:,} chars of noise)"
+
+        prompt = f"""<content_stats>
+{stats_summary}
+</content_stats>
+
+<webpage_content>
+{content}
+</webpage_content>"""
+        current_url = await self.browser_session.get_current_page_url()
+
+        return f"""<url>
+{current_url}
+</url>
+<content>
+{prompt}
+</content>"""

{openhands_tools-1.7.0 → openhands_tools-1.7.2}/openhands/tools/terminal/terminal/tmux_terminal.py

@@ -97,9 +97,11 @@ class TmuxTerminal(TerminalInterface):
         try:
             if hasattr(self, "session"):
                 self.session.kill()
-        except ImportError:
-            # Python is shutting down, let the OS handle cleanup
-            pass
+        except Exception as e:
+            # Session might already be dead/killed externally
+            # (e.g., "can't find session" error from tmux)
+            # Also handles ImportError during Python shutdown
+            logger.debug(f"Error closing tmux session (may already be dead): {e}")
         self._closed: bool = True
 
     def send_keys(self, text: str, enter: bool = True) -> None:

{openhands_tools-1.7.0 → openhands_tools-1.7.2}/openhands_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.7.0
+Version: 1.7.2
 Summary: OpenHands Tools - Runtime tools for AI agents
 Requires-Python: >=3.12
 Requires-Dist: openhands-sdk

{openhands_tools-1.7.0 → openhands_tools-1.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openhands-tools"
-version = "1.7.0"
+version = "1.7.2"
 description = "OpenHands Tools - Runtime tools for AI agents"
 
 requires-python = ">=3.12"

openhands_tools-1.7.0/openhands/tools/browser_use/server.py

@@ -1,100 +0,0 @@
-from browser_use.dom.markdown_extractor import extract_clean_markdown
-
-from openhands.sdk import get_logger
-from openhands.tools.browser_use.logging_fix import LogSafeBrowserUseServer
-
-
-logger = get_logger(__name__)
-
-
-class CustomBrowserUseServer(LogSafeBrowserUseServer):
-    """
-    Custom BrowserUseServer with a new tool for extracting web
-    page's content in markdown.
-    """
-
-    async def _get_content(self, extract_links=False, start_from_char: int = 0) -> str:
-        MAX_CHAR_LIMIT = 30000
-
-        if not self.browser_session:
-            return "Error: No browser session active"
-
-        # Extract clean markdown using the new method
-        try:
-            content, content_stats = await extract_clean_markdown(
-                browser_session=self.browser_session, extract_links=extract_links
-            )
-        except Exception as e:
-            logger.exception(
-                "Error extracting clean markdown", exc_info=e, stack_info=True
-            )
-            return f"Could not extract clean markdown: {type(e).__name__}"
-
-        # Original content length for processing
-        final_filtered_length = content_stats["final_filtered_chars"]
-
-        if start_from_char > 0:
-            if start_from_char >= len(content):
-                return f"start_from_char ({start_from_char}) exceeds content length ({len(content)}). Content has {final_filtered_length} characters after filtering."  # noqa: E501
-
-            content = content[start_from_char:]
-            content_stats["started_from_char"] = start_from_char
-
-        # Smart truncation with context preservation
-        truncated = False
-        if len(content) > MAX_CHAR_LIMIT:
-            # Try to truncate at a natural break point (paragraph, sentence)
-            truncate_at = MAX_CHAR_LIMIT
-
-            # Look for paragraph break within last 500 chars of limit
-            paragraph_break = content.rfind(
-                "\n\n", MAX_CHAR_LIMIT - 500, MAX_CHAR_LIMIT
-            )
-            if paragraph_break > 0:
-                truncate_at = paragraph_break
-            else:
-                # Look for sentence break within last 200 chars of limit
-                sentence_break = content.rfind(
-                    ".", MAX_CHAR_LIMIT - 200, MAX_CHAR_LIMIT
-                )
-                if sentence_break > 0:
-                    truncate_at = sentence_break + 1
-
-            content = content[:truncate_at]
-            truncated = True
-            next_start = (start_from_char or 0) + truncate_at
-            content_stats["truncated_at_char"] = truncate_at
-            content_stats["next_start_char"] = next_start
-
-        # Add content statistics to the result
-        original_html_length = content_stats["original_html_chars"]
-        initial_markdown_length = content_stats["initial_markdown_chars"]
-        chars_filtered = content_stats["filtered_chars_removed"]
-
-        stats_summary = (
-            f"Content processed: {original_html_length:,}"
-            + f" HTML chars → {initial_markdown_length:,}"
-            + f" initial markdown → {final_filtered_length:,} filtered markdown"
-        )
-        if start_from_char > 0:
-            stats_summary += f" (started from char {start_from_char:,})"
-        if truncated:
-            stats_summary += f" → {len(content):,} final chars (truncated, use start_from_char={content_stats['next_start_char']} to continue)"  # noqa: E501
-        elif chars_filtered > 0:
-            stats_summary += f" (filtered {chars_filtered:,} chars of noise)"
-
-        prompt = f"""<content_stats>
-{stats_summary}
-</content_stats>
-
-<webpage_content>
-{content}
-</webpage_content>"""
-        current_url = await self.browser_session.get_current_page_url()
-
-        return f"""<url>
-{current_url}
-</url>
-<content>
-{prompt}
-</content>"""