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

strix/tools/agents_graph/agents_graph_actions.py

@@ -190,36 +190,35 @@ def create_agent(
     task: str,
     name: str,
     inherit_context: bool = True,
-    prompt_modules: str | None = None,
+    skills: str | None = None,
 ) -> dict[str, Any]:
     try:
         parent_id = agent_state.agent_id
 
-        module_list = []
-        if prompt_modules:
-            module_list = [m.strip() for m in prompt_modules.split(",") if m.strip()]
+        skill_list = []
+        if skills:
+            skill_list = [s.strip() for s in skills.split(",") if s.strip()]
 
-        if len(module_list) > 5:
+        if len(skill_list) > 5:
             return {
                 "success": False,
                 "error": (
-                    "Cannot specify more than 5 prompt modules for an agent "
-                    "(use comma-separated format)"
+                    "Cannot specify more than 5 skills for an agent (use comma-separated format)"
                 ),
                 "agent_id": None,
             }
 
-        if module_list:
-            from strix.prompts import get_all_module_names, validate_module_names
+        if skill_list:
+            from strix.skills import get_all_skill_names, validate_skill_names
 
-            validation = validate_module_names(module_list)
+            validation = validate_skill_names(skill_list)
             if validation["invalid"]:
-                available_modules = list(get_all_module_names())
+                available_skills = list(get_all_skill_names())
                 return {
                     "success": False,
                     "error": (
-                        f"Invalid prompt modules: {validation['invalid']}. "
-                        f"Available modules: {', '.join(available_modules)}"
+                        f"Invalid skills: {validation['invalid']}. "
+                        f"Available skills: {', '.join(available_skills)}"
                     ),
                     "agent_id": None,
                 }
@@ -233,14 +232,14 @@ def create_agent(
         parent_agent = _agent_instances.get(parent_id)
 
         timeout = None
-        if (
-            parent_agent
-            and hasattr(parent_agent, "llm_config")
-            and hasattr(parent_agent.llm_config, "timeout")
-        ):
-            timeout = parent_agent.llm_config.timeout
-
-        llm_config = LLMConfig(prompt_modules=module_list, timeout=timeout)
+        scan_mode = "deep"
+        if parent_agent and hasattr(parent_agent, "llm_config"):
+            if hasattr(parent_agent.llm_config, "timeout"):
+                timeout = parent_agent.llm_config.timeout
+            if hasattr(parent_agent.llm_config, "scan_mode"):
+                scan_mode = parent_agent.llm_config.scan_mode
+
+        llm_config = LLMConfig(skills=skill_list, timeout=timeout, scan_mode=scan_mode)
 
         agent_config = {
             "llm_config": llm_config,

strix/tools/agents_graph/agents_graph_actions_schema.xml

@@ -79,8 +79,8 @@ Only create a new agent if no existing agent is handling the specific task.</des
       <parameter name="inherit_context" type="boolean" required="false">
         <description>Whether the new agent should inherit parent's conversation history and context</description>
       </parameter>
-      <parameter name="prompt_modules" type="string" required="false">
-        <description>Comma-separated list of prompt modules to use for the agent (MAXIMUM 5 modules allowed). Most agents should have at least one module in order to be useful. Agents should be highly specialized - use 1-3 related modules; up to 5 for complex contexts. {{DYNAMIC_MODULES_DESCRIPTION}}</description>
+      <parameter name="skills" type="string" required="false">
+        <description>Comma-separated list of skills to use for the agent (MAXIMUM 5 skills allowed). Most agents should have at least one skill in order to be useful. Agents should be highly specialized - use 1-3 related skills; up to 5 for complex contexts. {{DYNAMIC_SKILLS_DESCRIPTION}}</description>
       </parameter>
     </parameters>
     <returns type="Dict[str, Any]">
@@ -92,30 +92,30 @@ Only create a new agent if no existing agent is handling the specific task.</des
   <parameter=task>Validate and exploit the suspected SQL injection vulnerability found in
               the login form. Confirm exploitability and document proof of concept.</parameter>
   <parameter=name>SQLi Validator</parameter>
-  <parameter=prompt_modules>sql_injection</parameter>
+  <parameter=skills>sql_injection</parameter>
   </function>
 
   <function=create_agent>
   <parameter=task>Test authentication mechanisms, JWT implementation, and session management
               for security vulnerabilities and bypass techniques.</parameter>
   <parameter=name>Auth Specialist</parameter>
-  <parameter=prompt_modules>authentication_jwt, business_logic</parameter>
+  <parameter=skills>authentication_jwt, business_logic</parameter>
   </function>
 
-  # Example of single-module specialization (most focused)
+  # Example of single-skill specialization (most focused)
   <function=create_agent>
   <parameter=task>Perform comprehensive XSS testing including reflected, stored, and DOM-based
               variants across all identified input points.</parameter>
   <parameter=name>XSS Specialist</parameter>
-  <parameter=prompt_modules>xss</parameter>
+  <parameter=skills>xss</parameter>
   </function>
 
-  # Example of up to 5 related modules (borderline acceptable)
+  # Example of up to 5 related skills (borderline acceptable)
   <function=create_agent>
   <parameter=task>Test for server-side vulnerabilities including SSRF, XXE, and potential
               RCE vectors in file upload and XML processing endpoints.</parameter>
   <parameter=name>Server-Side Attack Specialist</parameter>
-  <parameter=prompt_modules>ssrf, xxe, rce</parameter>
+  <parameter=skills>ssrf, xxe, rce</parameter>
   </function>
     </examples>
   </tool>

strix/tools/browser/browser_actions.py

@@ -1,8 +1,10 @@
-from typing import Any, Literal, NoReturn
+from typing import TYPE_CHECKING, Any, Literal, NoReturn
 
 from strix.tools.registry import register_tool
 
-from .tab_manager import BrowserTabManager, get_browser_tab_manager
+
+if TYPE_CHECKING:
+    from .tab_manager import BrowserTabManager
 
 
 BrowserAction = Literal[
@@ -71,7 +73,7 @@ def _validate_file_path(action_name: str, file_path: str | None) -> None:
 
 
 def _handle_navigation_actions(
-    manager: BrowserTabManager,
+    manager: "BrowserTabManager",
     action: str,
     url: str | None = None,
     tab_id: str | None = None,
@@ -90,7 +92,7 @@ def _handle_navigation_actions(
 
 
 def _handle_interaction_actions(
-    manager: BrowserTabManager,
+    manager: "BrowserTabManager",
     action: str,
     coordinate: str | None = None,
     text: str | None = None,
@@ -128,7 +130,7 @@ def _raise_unknown_action(action: str) -> NoReturn:
 
 
 def _handle_tab_actions(
-    manager: BrowserTabManager,
+    manager: "BrowserTabManager",
     action: str,
     url: str | None = None,
     tab_id: str | None = None,
@@ -149,7 +151,7 @@ def _handle_tab_actions(
 
 
 def _handle_utility_actions(
-    manager: BrowserTabManager,
+    manager: "BrowserTabManager",
     action: str,
     duration: float | None = None,
     js_code: str | None = None,
@@ -191,6 +193,8 @@ def browser_action(
     file_path: str | None = None,
     clear: bool = False,
 ) -> dict[str, Any]:
+    from .tab_manager import get_browser_tab_manager
+
     manager = get_browser_tab_manager()
 
     try:

strix/tools/browser/browser_actions_schema.xml

@@ -1,4 +1,3 @@
-<?xml version="1.0" ?>
 <tools>
   <tool name="browser_action">
     <description>Perform browser actions using a Playwright-controlled browser with multiple tabs.
@@ -92,6 +91,12 @@
       code normally. It can be single line or multi-line.
   13. For form filling, click on the field first, then use 'type' to enter text.
   14. The browser runs in headless mode using Chrome engine for security and performance.
+  15. RESOURCE MANAGEMENT:
+      - ALWAYS close tabs you no longer need using 'close_tab' action.
+      - ALWAYS close the browser with 'close' action when you have completely finished
+        all browser-related tasks. Do not leave the browser running if you're done with it.
+      - If you opened multiple tabs, close them as soon as you've extracted the needed
+        information from each one.
     </notes>
     <examples>
   # Launch browser at URL (creates tab_1)

strix/tools/browser/browser_instance.py

@@ -1,5 +1,6 @@
 import asyncio
 import base64
+import contextlib
 import logging
 import threading
 from pathlib import Path
@@ -17,13 +18,82 @@ MAX_CONSOLE_LOGS_COUNT = 200
 MAX_JS_RESULT_LENGTH = 5_000
 
 
+class _BrowserState:
+    """Singleton state for the shared browser instance."""
+
+    lock = threading.Lock()
+    event_loop: asyncio.AbstractEventLoop | None = None
+    event_loop_thread: threading.Thread | None = None
+    playwright: Playwright | None = None
+    browser: Browser | None = None
+
+
+_state = _BrowserState()
+
+
+def _ensure_event_loop() -> None:
+    if _state.event_loop is not None:
+        return
+
+    def run_loop() -> None:
+        _state.event_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(_state.event_loop)
+        _state.event_loop.run_forever()
+
+    _state.event_loop_thread = threading.Thread(target=run_loop, daemon=True)
+    _state.event_loop_thread.start()
+
+    while _state.event_loop is None:
+        threading.Event().wait(0.01)
+
+
+async def _create_browser() -> Browser:
+    if _state.browser is not None and _state.browser.is_connected():
+        return _state.browser
+
+    if _state.browser is not None:
+        with contextlib.suppress(Exception):
+            await _state.browser.close()
+        _state.browser = None
+    if _state.playwright is not None:
+        with contextlib.suppress(Exception):
+            await _state.playwright.stop()
+        _state.playwright = None
+
+    _state.playwright = await async_playwright().start()
+    _state.browser = await _state.playwright.chromium.launch(
+        headless=True,
+        args=[
+            "--no-sandbox",
+            "--disable-dev-shm-usage",
+            "--disable-gpu",
+            "--disable-web-security",
+        ],
+    )
+    return _state.browser
+
+
+def _get_browser() -> tuple[asyncio.AbstractEventLoop, Browser]:
+    with _state.lock:
+        _ensure_event_loop()
+        assert _state.event_loop is not None
+
+        if _state.browser is None or not _state.browser.is_connected():
+            future = asyncio.run_coroutine_threadsafe(_create_browser(), _state.event_loop)
+            future.result(timeout=30)
+
+        assert _state.browser is not None
+        return _state.event_loop, _state.browser
+
+
 class BrowserInstance:
     def __init__(self) -> None:
         self.is_running = True
         self._execution_lock = threading.Lock()
 
-        self.playwright: Playwright | None = None
-        self.browser: Browser | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._browser: Browser | None = None
+
         self.context: BrowserContext | None = None
         self.pages: dict[str, Page] = {}
         self.current_page_id: str | None = None
@@ -31,23 +101,6 @@ class BrowserInstance:
 
         self.console_logs: dict[str, list[dict[str, Any]]] = {}
 
-        self._loop: asyncio.AbstractEventLoop | None = None
-        self._loop_thread: threading.Thread | None = None
-
-        self._start_event_loop()
-
-    def _start_event_loop(self) -> None:
-        def run_loop() -> None:
-            self._loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(self._loop)
-            self._loop.run_forever()
-
-        self._loop_thread = threading.Thread(target=run_loop, daemon=True)
-        self._loop_thread.start()
-
-        while self._loop is None:
-            threading.Event().wait(0.01)
-
     def _run_async(self, coro: Any) -> dict[str, Any]:
         if not self._loop or not self.is_running:
             raise RuntimeError("Browser instance is not running")
@@ -77,21 +130,10 @@ class BrowserInstance:
 
         page.on("console", handle_console)
 
-    async def _launch_browser(self, url: str | None = None) -> dict[str, Any]:
-        self.playwright = await async_playwright().start()
-
-        self.browser = await self.playwright.chromium.launch(
-            headless=True,
-            args=[
-                "--no-sandbox",
-                "--disable-dev-shm-usage",
-                "--disable-gpu",
-                "--disable-web-security",
-                "--disable-features=VizDisplayCompositor",
-            ],
-        )
+    async def _create_context(self, url: str | None = None) -> dict[str, Any]:
+        assert self._browser is not None
 
-        self.context = await self.browser.new_context(
+        self.context = await self._browser.new_context(
             viewport={"width": 1280, "height": 720},
             user_agent=(
                 "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
@@ -148,10 +190,11 @@ class BrowserInstance:
 
     def launch(self, url: str | None = None) -> dict[str, Any]:
         with self._execution_lock:
-            if self.browser is not None:
+            if self.context is not None:
                 raise ValueError("Browser is already launched")
 
-            return self._run_async(self._launch_browser(url))
+            self._loop, self._browser = _get_browser()
+            return self._run_async(self._create_context(url))
 
     def goto(self, url: str, tab_id: str | None = None) -> dict[str, Any]:
         with self._execution_lock:
@@ -512,22 +555,27 @@ class BrowserInstance:
     def close(self) -> None:
         with self._execution_lock:
             self.is_running = False
-            if self._loop:
-                asyncio.run_coroutine_threadsafe(self._close_browser(), self._loop)
-
-                self._loop.call_soon_threadsafe(self._loop.stop)
+            if self._loop and self.context:
+                future = asyncio.run_coroutine_threadsafe(self._close_context(), self._loop)
+                with contextlib.suppress(Exception):
+                    future.result(timeout=5)
 
-                if self._loop_thread:
-                    self._loop_thread.join(timeout=5)
+            self.pages.clear()
+            self.console_logs.clear()
+            self.current_page_id = None
+            self.context = None
 
-    async def _close_browser(self) -> None:
+    async def _close_context(self) -> None:
         try:
-            if self.browser:
-                await self.browser.close()
-            if self.playwright:
-                await self.playwright.stop()
+            if self.context:
+                await self.context.close()
         except (OSError, RuntimeError) as e:
-            logger.warning(f"Error closing browser: {e}")
+            logger.warning(f"Error closing context: {e}")
 
     def is_alive(self) -> bool:
-        return self.is_running and self.browser is not None and self.browser.is_connected()
+        return (
+            self.is_running
+            and self.context is not None
+            and self._browser is not None
+            and self._browser.is_connected()
+        )