strix-agent 0.4.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

strix/tools/browser/tab_manager.py

@@ -1,43 +1,56 @@
 import atexit
 import contextlib
-import signal
-import sys
 import threading
 from typing import Any
 
+from strix.tools.context import get_current_agent_id
+
 from .browser_instance import BrowserInstance
 
 
 class BrowserTabManager:
     def __init__(self) -> None:
-        self.browser_instance: BrowserInstance | None = None
+        self._browsers_by_agent: dict[str, BrowserInstance] = {}
         self._lock = threading.Lock()
 
         self._register_cleanup_handlers()
 
+    def _get_agent_browser(self) -> BrowserInstance | None:
+        agent_id = get_current_agent_id()
+        with self._lock:
+            return self._browsers_by_agent.get(agent_id)
+
+    def _set_agent_browser(self, browser: BrowserInstance | None) -> None:
+        agent_id = get_current_agent_id()
+        with self._lock:
+            if browser is None:
+                self._browsers_by_agent.pop(agent_id, None)
+            else:
+                self._browsers_by_agent[agent_id] = browser
+
     def launch_browser(self, url: str | None = None) -> dict[str, Any]:
         with self._lock:
-            if self.browser_instance is not None:
+            agent_id = get_current_agent_id()
+            if agent_id in self._browsers_by_agent:
                 raise ValueError("Browser is already launched")
 
             try:
-                self.browser_instance = BrowserInstance()
-                result = self.browser_instance.launch(url)
+                browser = BrowserInstance()
+                result = browser.launch(url)
+                self._browsers_by_agent[agent_id] = browser
                 result["message"] = "Browser launched successfully"
             except (OSError, ValueError, RuntimeError) as e:
-                if self.browser_instance:
-                    self.browser_instance = None
                 raise RuntimeError(f"Failed to launch browser: {e}") from e
             else:
                 return result
 
     def goto_url(self, url: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.goto(url, tab_id)
+            result = browser.goto(url, tab_id)
             result["message"] = f"Navigated to {url}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to navigate to URL: {e}") from e
@@ -45,12 +58,12 @@ class BrowserTabManager:
             return result
 
     def click(self, coordinate: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.click(coordinate, tab_id)
+            result = browser.click(coordinate, tab_id)
             result["message"] = f"Clicked at {coordinate}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to click: {e}") from e
@@ -58,12 +71,12 @@ class BrowserTabManager:
             return result
 
     def type_text(self, text: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.type_text(text, tab_id)
+            result = browser.type_text(text, tab_id)
             result["message"] = f"Typed text: {text[:50]}{'...' if len(text) > 50 else ''}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to type text: {e}") from e
@@ -71,12 +84,12 @@ class BrowserTabManager:
             return result
 
     def scroll(self, direction: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.scroll(direction, tab_id)
+            result = browser.scroll(direction, tab_id)
             result["message"] = f"Scrolled {direction}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to scroll: {e}") from e
@@ -84,12 +97,12 @@ class BrowserTabManager:
             return result
 
     def back(self, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.back(tab_id)
+            result = browser.back(tab_id)
             result["message"] = "Navigated back"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to go back: {e}") from e
@@ -97,12 +110,12 @@ class BrowserTabManager:
             return result
 
     def forward(self, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.forward(tab_id)
+            result = browser.forward(tab_id)
             result["message"] = "Navigated forward"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to go forward: {e}") from e
@@ -110,12 +123,12 @@ class BrowserTabManager:
             return result
 
     def new_tab(self, url: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.new_tab(url)
+            result = browser.new_tab(url)
             result["message"] = f"Created new tab {result.get('tab_id', '')}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to create new tab: {e}") from e
@@ -123,12 +136,12 @@ class BrowserTabManager:
             return result
 
     def switch_tab(self, tab_id: str) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.switch_tab(tab_id)
+            result = browser.switch_tab(tab_id)
             result["message"] = f"Switched to tab {tab_id}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to switch tab: {e}") from e
@@ -136,12 +149,12 @@ class BrowserTabManager:
             return result
 
     def close_tab(self, tab_id: str) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.close_tab(tab_id)
+            result = browser.close_tab(tab_id)
             result["message"] = f"Closed tab {tab_id}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to close tab: {e}") from e
@@ -149,12 +162,12 @@ class BrowserTabManager:
             return result
 
     def wait_browser(self, duration: float, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.wait(duration, tab_id)
+            result = browser.wait(duration, tab_id)
             result["message"] = f"Waited {duration}s"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to wait: {e}") from e
@@ -162,12 +175,12 @@ class BrowserTabManager:
             return result
 
     def execute_js(self, js_code: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.execute_js(js_code, tab_id)
+            result = browser.execute_js(js_code, tab_id)
             result["message"] = "JavaScript executed successfully"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to execute JavaScript: {e}") from e
@@ -175,12 +188,12 @@ class BrowserTabManager:
             return result
 
     def double_click(self, coordinate: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.double_click(coordinate, tab_id)
+            result = browser.double_click(coordinate, tab_id)
             result["message"] = f"Double clicked at {coordinate}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to double click: {e}") from e
@@ -188,12 +201,12 @@ class BrowserTabManager:
             return result
 
     def hover(self, coordinate: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.hover(coordinate, tab_id)
+            result = browser.hover(coordinate, tab_id)
             result["message"] = f"Hovered at {coordinate}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to hover: {e}") from e
@@ -201,12 +214,12 @@ class BrowserTabManager:
             return result
 
     def press_key(self, key: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.press_key(key, tab_id)
+            result = browser.press_key(key, tab_id)
             result["message"] = f"Pressed key {key}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to press key: {e}") from e
@@ -214,12 +227,12 @@ class BrowserTabManager:
             return result
 
     def save_pdf(self, file_path: str, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.save_pdf(file_path, tab_id)
+            result = browser.save_pdf(file_path, tab_id)
             result["message"] = f"Page saved as PDF: {file_path}"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to save PDF: {e}") from e
@@ -227,12 +240,12 @@ class BrowserTabManager:
             return result
 
     def get_console_logs(self, tab_id: str | None = None, clear: bool = False) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.get_console_logs(tab_id, clear)
+            result = browser.get_console_logs(tab_id, clear)
             action_text = "cleared and retrieved" if clear else "retrieved"
 
             logs = result.get("console_logs", [])
@@ -249,12 +262,12 @@ class BrowserTabManager:
             return result
 
     def view_source(self, tab_id: str | None = None) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                raise ValueError("Browser not launched")
+        browser = self._get_agent_browser()
+        if browser is None:
+            raise ValueError("Browser not launched")
 
         try:
-            result = self.browser_instance.view_source(tab_id)
+            result = browser.view_source(tab_id)
             result["message"] = "Page source retrieved"
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to get page source: {e}") from e
@@ -262,18 +275,18 @@ class BrowserTabManager:
             return result
 
     def list_tabs(self) -> dict[str, Any]:
-        with self._lock:
-            if self.browser_instance is None:
-                return {"tabs": {}, "total_count": 0, "current_tab": None}
+        browser = self._get_agent_browser()
+        if browser is None:
+            return {"tabs": {}, "total_count": 0, "current_tab": None}
 
         try:
             tab_info = {}
-            for tid, tab_page in self.browser_instance.pages.items():
+            for tid, tab_page in browser.pages.items():
                 try:
                     tab_info[tid] = {
                         "url": tab_page.url,
                         "title": "Unknown" if tab_page.is_closed() else "Active",
-                        "is_current": tid == self.browser_instance.current_page_id,
+                        "is_current": tid == browser.current_page_id,
                     }
                 except (AttributeError, RuntimeError):
                     tab_info[tid] = {
@@ -285,19 +298,20 @@ class BrowserTabManager:
             return {
                 "tabs": tab_info,
                 "total_count": len(tab_info),
-                "current_tab": self.browser_instance.current_page_id,
+                "current_tab": browser.current_page_id,
             }
         except (OSError, ValueError, RuntimeError) as e:
             raise RuntimeError(f"Failed to list tabs: {e}") from e
 
     def close_browser(self) -> dict[str, Any]:
+        agent_id = get_current_agent_id()
         with self._lock:
-            if self.browser_instance is None:
+            browser = self._browsers_by_agent.pop(agent_id, None)
+            if browser is None:
                 raise ValueError("Browser not launched")
 
             try:
-                self.browser_instance.close()
-                self.browser_instance = None
+                browser.close()
             except (OSError, ValueError, RuntimeError) as e:
                 raise RuntimeError(f"Failed to close browser: {e}") from e
             else:
@@ -307,33 +321,38 @@ class BrowserTabManager:
                     "is_running": False,
                 }
 
+    def cleanup_agent(self, agent_id: str) -> None:
+        with self._lock:
+            browser = self._browsers_by_agent.pop(agent_id, None)
+
+        if browser:
+            with contextlib.suppress(Exception):
+                browser.close()
+
     def cleanup_dead_browser(self) -> None:
         with self._lock:
-            if self.browser_instance and not self.browser_instance.is_alive():
+            dead_agents = []
+            for agent_id, browser in self._browsers_by_agent.items():
+                if not browser.is_alive():
+                    dead_agents.append(agent_id)
+
+            for agent_id in dead_agents:
+                browser = self._browsers_by_agent.pop(agent_id)
                 with contextlib.suppress(Exception):
-                    self.browser_instance.close()
-                self.browser_instance = None
+                    browser.close()
 
     def close_all(self) -> None:
         with self._lock:
-            if self.browser_instance:
-                with contextlib.suppress(Exception):
-                    self.browser_instance.close()
-                self.browser_instance = None
+            browsers = list(self._browsers_by_agent.values())
+            self._browsers_by_agent.clear()
+
+        for browser in browsers:
+            with contextlib.suppress(Exception):
+                browser.close()
 
     def _register_cleanup_handlers(self) -> None:
         atexit.register(self.close_all)
 
-        signal.signal(signal.SIGTERM, self._signal_handler)
-        signal.signal(signal.SIGINT, self._signal_handler)
-
-        if hasattr(signal, "SIGHUP"):
-            signal.signal(signal.SIGHUP, self._signal_handler)
-
-    def _signal_handler(self, _signum: int, _frame: Any) -> None:
-        self.close_all()
-        sys.exit(0)
-
 
 _browser_tab_manager = BrowserTabManager()
 

strix/tools/context.py

@@ -0,0 +1,12 @@
+from contextvars import ContextVar
+
+
+current_agent_id: ContextVar[str] = ContextVar("current_agent_id", default="default")
+
+
+def get_current_agent_id() -> str:
+    return current_agent_id.get()
+
+
+def set_current_agent_id(agent_id: str) -> None:
+    current_agent_id.set(agent_id)

strix/tools/executor.py

@@ -4,6 +4,9 @@ from typing import Any
 
 import httpx
 
+from strix.config import Config
+from strix.telemetry import posthog
+
 
 if os.getenv("STRIX_SANDBOX_MODE", "false").lower() == "false":
     from strix.runtime import get_runtime
@@ -12,11 +15,17 @@ from .argument_parser import convert_arguments
 from .registry import (
     get_tool_by_name,
     get_tool_names,
+    get_tool_param_schema,
     needs_agent_state,
     should_execute_in_sandbox,
 )
 
 
+_SERVER_TIMEOUT = float(Config.get("strix_sandbox_execution_timeout") or "120")
+SANDBOX_EXECUTION_TIMEOUT = _SERVER_TIMEOUT + 30
+SANDBOX_CONNECT_TIMEOUT = float(Config.get("strix_sandbox_connect_timeout") or "10")
+
+
 async def execute_tool(tool_name: str, agent_state: Any | None = None, **kwargs: Any) -> Any:
     execute_in_sandbox = should_execute_in_sandbox(tool_name)
     sandbox_mode = os.getenv("STRIX_SANDBOX_MODE", "false").lower() == "true"
@@ -62,22 +71,31 @@ async def _execute_tool_in_sandbox(tool_name: str, agent_state: Any, **kwargs: A
         "Content-Type": "application/json",
     }
 
+    timeout = httpx.Timeout(
+        timeout=SANDBOX_EXECUTION_TIMEOUT,
+        connect=SANDBOX_CONNECT_TIMEOUT,
+    )
+
     async with httpx.AsyncClient(trust_env=False) as client:
         try:
             response = await client.post(
-                request_url, json=request_data, headers=headers, timeout=None
+                request_url, json=request_data, headers=headers, timeout=timeout
             )
             response.raise_for_status()
             response_data = response.json()
             if response_data.get("error"):
+                posthog.error("tool_execution_error", f"{tool_name}: {response_data['error']}")
                 raise RuntimeError(f"Sandbox execution error: {response_data['error']}")
             return response_data.get("result")
         except httpx.HTTPStatusError as e:
+            posthog.error("tool_http_error", f"{tool_name}: HTTP {e.response.status_code}")
             if e.response.status_code == 401:
                 raise RuntimeError("Authentication failed: Invalid or missing sandbox token") from e
             raise RuntimeError(f"HTTP error calling tool server: {e.response.status_code}") from e
         except httpx.RequestError as e:
-            raise RuntimeError(f"Request error calling tool server: {e}") from e
+            error_type = type(e).__name__
+            posthog.error("tool_request_error", f"{tool_name}: {error_type}")
+            raise RuntimeError(f"Request error calling tool server: {error_type}") from e
 
 
 async def _execute_tool_locally(tool_name: str, agent_state: Any | None, **kwargs: Any) -> Any:
@@ -99,14 +117,51 @@ async def _execute_tool_locally(tool_name: str, agent_state: Any | None, **kwarg
 
 def validate_tool_availability(tool_name: str | None) -> tuple[bool, str]:
     if tool_name is None:
-        return False, "Tool name is missing"
+        available = ", ".join(sorted(get_tool_names()))
+        return False, f"Tool name is missing. Available tools: {available}"
 
     if tool_name not in get_tool_names():
-        return False, f"Tool '{tool_name}' is not available"
+        available = ", ".join(sorted(get_tool_names()))
+        return False, f"Tool '{tool_name}' is not available. Available tools: {available}"
 
     return True, ""
 
 
+def _validate_tool_arguments(tool_name: str, kwargs: dict[str, Any]) -> str | None:
+    param_schema = get_tool_param_schema(tool_name)
+    if not param_schema or not param_schema.get("has_params"):
+        return None
+
+    allowed_params: set[str] = param_schema.get("params", set())
+    required_params: set[str] = param_schema.get("required", set())
+    optional_params = allowed_params - required_params
+
+    schema_hint = _format_schema_hint(tool_name, required_params, optional_params)
+
+    unknown_params = set(kwargs.keys()) - allowed_params
+    if unknown_params:
+        unknown_list = ", ".join(sorted(unknown_params))
+        return f"Tool '{tool_name}' received unknown parameter(s): {unknown_list}\n{schema_hint}"
+
+    missing_required = [
+        param for param in required_params if param not in kwargs or kwargs.get(param) in (None, "")
+    ]
+    if missing_required:
+        missing_list = ", ".join(sorted(missing_required))
+        return f"Tool '{tool_name}' missing required parameter(s): {missing_list}\n{schema_hint}"
+
+    return None
+
+
+def _format_schema_hint(tool_name: str, required: set[str], optional: set[str]) -> str:
+    parts = [f"Valid parameters for '{tool_name}':"]
+    if required:
+        parts.append(f"  Required: {', '.join(sorted(required))}")
+    if optional:
+        parts.append(f"  Optional: {', '.join(sorted(optional))}")
+    return "\n".join(parts)
+
+
 async def execute_tool_with_validation(
     tool_name: str | None, agent_state: Any | None = None, **kwargs: Any
 ) -> Any:
@@ -116,6 +171,10 @@ async def execute_tool_with_validation(
 
     assert tool_name is not None
 
+    arg_error = _validate_tool_arguments(tool_name, kwargs)
+    if arg_error:
+        return f"Error: {arg_error}"
+
     try:
         result = await execute_tool(tool_name, agent_state, **kwargs)
     except Exception as e:  # noqa: BLE001

strix/tools/file_edit/file_edit_actions.py

@@ -3,9 +3,6 @@ import re
 from pathlib import Path
 from typing import Any, cast
 
-from openhands_aci import file_editor
-from openhands_aci.utils.shell import run_shell_cmd
-
 from strix.tools.registry import register_tool
 
 
@@ -33,6 +30,8 @@ def str_replace_editor(
     new_str: str | None = None,
     insert_line: int | None = None,
 ) -> dict[str, Any]:
+    from openhands_aci import file_editor
+
     try:
         path_obj = Path(path)
         if not path_obj.is_absolute():
@@ -64,6 +63,8 @@ def list_files(
     path: str,
     recursive: bool = False,
 ) -> dict[str, Any]:
+    from openhands_aci.utils.shell import run_shell_cmd
+
     try:
         path_obj = Path(path)
         if not path_obj.is_absolute():
@@ -116,6 +117,8 @@ def search_files(
     regex: str,
     file_pattern: str = "*",
 ) -> dict[str, Any]:
+    from openhands_aci.utils.shell import run_shell_cmd
+
     try:
         path_obj = Path(path)
         if not path_obj.is_absolute():