strix-agent 0.4.0__py3-none-any.whl

strix/tools/browser/tab_manager.py

@@ -0,0 +1,342 @@
+import atexit
+import contextlib
+import signal
+import sys
+import threading
+from typing import Any
+
+from .browser_instance import BrowserInstance
+
+
+class BrowserTabManager:
+    def __init__(self) -> None:
+        self.browser_instance: BrowserInstance | None = None
+        self._lock = threading.Lock()
+
+        self._register_cleanup_handlers()
+
+    def launch_browser(self, url: str | None = None) -> dict[str, Any]:
+        with self._lock:
+            if self.browser_instance is not None:
+                raise ValueError("Browser is already launched")
+
+            try:
+                self.browser_instance = BrowserInstance()
+                result = self.browser_instance.launch(url)
+                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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.scroll(direction, tab_id)
+            result["message"] = f"Scrolled {direction}"
+        except (OSError, ValueError, RuntimeError) as e:
+            raise RuntimeError(f"Failed to scroll: {e}") from e
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.back(tab_id)
+            result["message"] = "Navigated back"
+        except (OSError, ValueError, RuntimeError) as e:
+            raise RuntimeError(f"Failed to go back: {e}") from e
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.forward(tab_id)
+            result["message"] = "Navigated forward"
+        except (OSError, ValueError, RuntimeError) as e:
+            raise RuntimeError(f"Failed to go forward: {e}") from e
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.get_console_logs(tab_id, clear)
+            action_text = "cleared and retrieved" if clear else "retrieved"
+
+            logs = result.get("console_logs", [])
+            truncated = any(log.get("text", "").startswith("[TRUNCATED:") for log in logs)
+            truncated_text = " (truncated)" if truncated else ""
+
+            result["message"] = (
+                f"Console logs {action_text} for tab "
+                f"{result.get('tab_id', 'current')}{truncated_text}"
+            )
+        except (OSError, ValueError, RuntimeError) as e:
+            raise RuntimeError(f"Failed to get console logs: {e}") from e
+        else:
+            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")
+
+        try:
+            result = self.browser_instance.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
+        else:
+            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}
+
+        try:
+            tab_info = {}
+            for tid, tab_page in self.browser_instance.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,
+                    }
+                except (AttributeError, RuntimeError):
+                    tab_info[tid] = {
+                        "url": "Unknown",
+                        "title": "Closed",
+                        "is_current": False,
+                    }
+
+            return {
+                "tabs": tab_info,
+                "total_count": len(tab_info),
+                "current_tab": self.browser_instance.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]:
+        with self._lock:
+            if self.browser_instance is None:
+                raise ValueError("Browser not launched")
+
+            try:
+                self.browser_instance.close()
+                self.browser_instance = None
+            except (OSError, ValueError, RuntimeError) as e:
+                raise RuntimeError(f"Failed to close browser: {e}") from e
+            else:
+                return {
+                    "message": "Browser closed successfully",
+                    "screenshot": "",
+                    "is_running": False,
+                }
+
+    def cleanup_dead_browser(self) -> None:
+        with self._lock:
+            if self.browser_instance and not self.browser_instance.is_alive():
+                with contextlib.suppress(Exception):
+                    self.browser_instance.close()
+                self.browser_instance = None
+
+    def close_all(self) -> None:
+        with self._lock:
+            if self.browser_instance:
+                with contextlib.suppress(Exception):
+                    self.browser_instance.close()
+                self.browser_instance = None
+
+    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()
+
+
+def get_browser_tab_manager() -> BrowserTabManager:
+    return _browser_tab_manager

strix/tools/executor.py

@@ -0,0 +1,305 @@
+import inspect
+import os
+from typing import Any
+
+import httpx
+
+
+if os.getenv("STRIX_SANDBOX_MODE", "false").lower() == "false":
+    from strix.runtime import get_runtime
+
+from .argument_parser import convert_arguments
+from .registry import (
+    get_tool_by_name,
+    get_tool_names,
+    needs_agent_state,
+    should_execute_in_sandbox,
+)
+
+
+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"
+
+    if execute_in_sandbox and not sandbox_mode:
+        return await _execute_tool_in_sandbox(tool_name, agent_state, **kwargs)
+
+    return await _execute_tool_locally(tool_name, agent_state, **kwargs)
+
+
+async def _execute_tool_in_sandbox(tool_name: str, agent_state: Any, **kwargs: Any) -> Any:
+    if not hasattr(agent_state, "sandbox_id") or not agent_state.sandbox_id:
+        raise ValueError("Agent state with a valid sandbox_id is required for sandbox execution.")
+
+    if not hasattr(agent_state, "sandbox_token") or not agent_state.sandbox_token:
+        raise ValueError(
+            "Agent state with a valid sandbox_token is required for sandbox execution."
+        )
+
+    if (
+        not hasattr(agent_state, "sandbox_info")
+        or "tool_server_port" not in agent_state.sandbox_info
+    ):
+        raise ValueError(
+            "Agent state with a valid sandbox_info containing tool_server_port is required."
+        )
+
+    runtime = get_runtime()
+    tool_server_port = agent_state.sandbox_info["tool_server_port"]
+    server_url = await runtime.get_sandbox_url(agent_state.sandbox_id, tool_server_port)
+    request_url = f"{server_url}/execute"
+
+    agent_id = getattr(agent_state, "agent_id", "unknown")
+
+    request_data = {
+        "agent_id": agent_id,
+        "tool_name": tool_name,
+        "kwargs": kwargs,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {agent_state.sandbox_token}",
+        "Content-Type": "application/json",
+    }
+
+    async with httpx.AsyncClient(trust_env=False) as client:
+        try:
+            response = await client.post(
+                request_url, json=request_data, headers=headers, timeout=None
+            )
+            response.raise_for_status()
+            response_data = response.json()
+            if response_data.get("error"):
+                raise RuntimeError(f"Sandbox execution error: {response_data['error']}")
+            return response_data.get("result")
+        except httpx.HTTPStatusError as e:
+            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
+
+
+async def _execute_tool_locally(tool_name: str, agent_state: Any | None, **kwargs: Any) -> Any:
+    tool_func = get_tool_by_name(tool_name)
+    if not tool_func:
+        raise ValueError(f"Tool '{tool_name}' not found")
+
+    converted_kwargs = convert_arguments(tool_func, kwargs)
+
+    if needs_agent_state(tool_name):
+        if agent_state is None:
+            raise ValueError(f"Tool '{tool_name}' requires agent_state but none was provided.")
+        result = tool_func(agent_state=agent_state, **converted_kwargs)
+    else:
+        result = tool_func(**converted_kwargs)
+
+    return await result if inspect.isawaitable(result) else result
+
+
+def validate_tool_availability(tool_name: str | None) -> tuple[bool, str]:
+    if tool_name is None:
+        return False, "Tool name is missing"
+
+    if tool_name not in get_tool_names():
+        return False, f"Tool '{tool_name}' is not available"
+
+    return True, ""
+
+
+async def execute_tool_with_validation(
+    tool_name: str | None, agent_state: Any | None = None, **kwargs: Any
+) -> Any:
+    is_valid, error_msg = validate_tool_availability(tool_name)
+    if not is_valid:
+        return f"Error: {error_msg}"
+
+    assert tool_name is not None
+
+    try:
+        result = await execute_tool(tool_name, agent_state, **kwargs)
+    except Exception as e:  # noqa: BLE001
+        error_str = str(e)
+        if len(error_str) > 500:
+            error_str = error_str[:500] + "... [truncated]"
+        return f"Error executing {tool_name}: {error_str}"
+    else:
+        return result
+
+
+async def execute_tool_invocation(tool_inv: dict[str, Any], agent_state: Any | None = None) -> Any:
+    tool_name = tool_inv.get("toolName")
+    tool_args = tool_inv.get("args", {})
+
+    return await execute_tool_with_validation(tool_name, agent_state, **tool_args)
+
+
+def _check_error_result(result: Any) -> tuple[bool, Any]:
+    is_error = False
+    error_payload: Any = None
+
+    if (isinstance(result, dict) and "error" in result) or (
+        isinstance(result, str) and result.strip().lower().startswith("error:")
+    ):
+        is_error = True
+        error_payload = result
+
+    return is_error, error_payload
+
+
+def _update_tracer_with_result(
+    tracer: Any, execution_id: Any, is_error: bool, result: Any, error_payload: Any
+) -> None:
+    if not tracer or not execution_id:
+        return
+
+    try:
+        if is_error:
+            tracer.update_tool_execution(execution_id, "error", error_payload)
+        else:
+            tracer.update_tool_execution(execution_id, "completed", result)
+    except (ConnectionError, RuntimeError) as e:
+        error_msg = str(e)
+        if tracer and execution_id:
+            tracer.update_tool_execution(execution_id, "error", error_msg)
+        raise
+
+
+def _format_tool_result(tool_name: str, result: Any) -> tuple[str, list[dict[str, Any]]]:
+    images: list[dict[str, Any]] = []
+
+    screenshot_data = extract_screenshot_from_result(result)
+    if screenshot_data:
+        images.append(
+            {
+                "type": "image_url",
+                "image_url": {"url": f"data:image/png;base64,{screenshot_data}"},
+            }
+        )
+        result_str = remove_screenshot_from_result(result)
+    else:
+        result_str = result
+
+    if result_str is None:
+        final_result_str = f"Tool {tool_name} executed successfully"
+    else:
+        final_result_str = str(result_str)
+        if len(final_result_str) > 10000:
+            start_part = final_result_str[:4000]
+            end_part = final_result_str[-4000:]
+            final_result_str = start_part + "\n\n... [middle content truncated] ...\n\n" + end_part
+
+    observation_xml = (
+        f"<tool_result>\n<tool_name>{tool_name}</tool_name>\n"
+        f"<result>{final_result_str}</result>\n</tool_result>"
+    )
+
+    return observation_xml, images
+
+
+async def _execute_single_tool(
+    tool_inv: dict[str, Any],
+    agent_state: Any | None,
+    tracer: Any | None,
+    agent_id: str,
+) -> tuple[str, list[dict[str, Any]], bool]:
+    tool_name = tool_inv.get("toolName", "unknown")
+    args = tool_inv.get("args", {})
+    execution_id = None
+    should_agent_finish = False
+
+    if tracer:
+        execution_id = tracer.log_tool_execution_start(agent_id, tool_name, args)
+
+    try:
+        result = await execute_tool_invocation(tool_inv, agent_state)
+
+        is_error, error_payload = _check_error_result(result)
+
+        if (
+            tool_name in ("finish_scan", "agent_finish")
+            and not is_error
+            and isinstance(result, dict)
+        ):
+            if tool_name == "finish_scan":
+                should_agent_finish = result.get("scan_completed", False)
+            elif tool_name == "agent_finish":
+                should_agent_finish = result.get("agent_completed", False)
+
+        _update_tracer_with_result(tracer, execution_id, is_error, result, error_payload)
+
+    except (ConnectionError, RuntimeError, ValueError, TypeError, OSError) as e:
+        error_msg = str(e)
+        if tracer and execution_id:
+            tracer.update_tool_execution(execution_id, "error", error_msg)
+        raise
+
+    observation_xml, images = _format_tool_result(tool_name, result)
+    return observation_xml, images, should_agent_finish
+
+
+def _get_tracer_and_agent_id(agent_state: Any | None) -> tuple[Any | None, str]:
+    try:
+        from strix.telemetry.tracer import get_global_tracer
+
+        tracer = get_global_tracer()
+        agent_id = agent_state.agent_id if agent_state else "unknown_agent"
+    except (ImportError, AttributeError):
+        tracer = None
+        agent_id = "unknown_agent"
+
+    return tracer, agent_id
+
+
+async def process_tool_invocations(
+    tool_invocations: list[dict[str, Any]],
+    conversation_history: list[dict[str, Any]],
+    agent_state: Any | None = None,
+) -> bool:
+    observation_parts: list[str] = []
+    all_images: list[dict[str, Any]] = []
+    should_agent_finish = False
+
+    tracer, agent_id = _get_tracer_and_agent_id(agent_state)
+
+    for tool_inv in tool_invocations:
+        observation_xml, images, tool_should_finish = await _execute_single_tool(
+            tool_inv, agent_state, tracer, agent_id
+        )
+        observation_parts.append(observation_xml)
+        all_images.extend(images)
+
+        if tool_should_finish:
+            should_agent_finish = True
+
+    if all_images:
+        content = [{"type": "text", "text": "Tool Results:\n\n" + "\n\n".join(observation_parts)}]
+        content.extend(all_images)
+        conversation_history.append({"role": "user", "content": content})
+    else:
+        observation_content = "Tool Results:\n\n" + "\n\n".join(observation_parts)
+        conversation_history.append({"role": "user", "content": observation_content})
+
+    return should_agent_finish
+
+
+def extract_screenshot_from_result(result: Any) -> str | None:
+    if not isinstance(result, dict):
+        return None
+
+    screenshot = result.get("screenshot")
+    if isinstance(screenshot, str) and screenshot:
+        return screenshot
+
+    return None
+
+
+def remove_screenshot_from_result(result: Any) -> Any:
+    if not isinstance(result, dict):
+        return result
+
+    result_copy = result.copy()
+    if "screenshot" in result_copy:
+        result_copy["screenshot"] = "[Image data extracted - see attached image]"
+
+    return result_copy

strix/tools/file_edit/__init__.py

@@ -0,0 +1,4 @@
+from .file_edit_actions import list_files, search_files, str_replace_editor
+
+
+__all__ = ["list_files", "search_files", "str_replace_editor"]