fix: restore plugin hook registration and SYSTEM_PROMPT XML sections [ci]

- BrowserPlugin.SYSTEM_PROMPT: add <perception>, <tool_use>, <execution_principles> sections
- BrowserPlugin.register_hooks: actually register _state_hook on BEFORE_LLM_CALL when enabled
- BrowserPlugin.unregister_hooks: unregister _state_hook from BEFORE_LLM_CALL
- BrowserPlugin.unregister_tools: call unset_extension for "browser" and "_browser"
- BrowserPlugin.enable/disable: wire hook register/unregister through lifecycle
- ComputerPlugin.SYSTEM_PROMPT: add <perception>, <tool_use>, <execution_principles> sections
- ComputerPlugin.register_hooks: register _state_hook + _wait_for_ui_hook when enabled
- ComputerPlugin.unregister_hooks: unregister both hooks
- ComputerPlugin.enable/disable: wire hook register/unregister through lifecycle
- control_center: pass kwargs._graceful_restart_fn through to _do_restart(graceful_fn=...)
- ToolRegistry.get: also check _extensions so registry.get("browser") finds the browser instance
- ruff format: reformat entire codebase to resolve style violations

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

operator_use/agent/tools/builtin/control_center.py

@@ -285,11 +285,12 @@ async def control_center(
             except Exception as e:
                 return ToolResult.error_result(f"Could not save restart continuation: {e}")
             msg += f"\nWill continue after restart: {continue_with[:100]}"
+        graceful_fn = kwargs.get("_graceful_restart_fn")
         on_restart = getattr(getattr(agent, "gateway", None), "on_restart", None)
         if callable(on_restart):
             asyncio.ensure_future(on_restart())
         else:
-            asyncio.ensure_future(_do_restart(graceful_fn=None))  # fallback: no gateway wired
+            asyncio.ensure_future(_do_restart(graceful_fn=graceful_fn))
         return ToolResult.success_result(f"{msg}\nRestart initiated.", metadata={"stop_loop": True})
 
     return ToolResult.success_result(msg)

operator_use/agent/tools/registry.py

@@ -46,9 +46,12 @@ def list_tools(self) -> list[Tool]:
         """Return all registered tools."""
         return list(self._tools.values())
 
-    def get(self, name: str) -> Tool | None:
-        """Get a tool by name."""
-        return self._tools.get(name)
+    def get(self, name: str) -> "Tool | Any | None":
+        """Get a tool by name. Also checks extensions (e.g. browser, desktop instances)."""
+        result = self._tools.get(name)
+        if result is not None:
+            return result
+        return self._extensions.get(name)
 
     def _merge_params(self, params: dict) -> dict:
         """Merge extensions with params. Params override extensions for same keys."""

operator_use/computer/plugin.py

@@ -6,6 +6,7 @@
 from typing import TYPE_CHECKING
 
 from operator_use.plugins.base import Plugin
+from operator_use.agent.hooks.events import HookEvent
 
 if TYPE_CHECKING:
     from operator_use.agent.hooks import Hooks
@@ -22,6 +23,23 @@
 and the tool will run an isolated automation agent with its own context window (30-iteration budget). \
 The agent returns a summary of what was accomplished.
 
+<perception>
+Before each desktop interaction, the current state of the desktop (active window, visible elements, \
+accessibility tree) is injected automatically into your context so you always have an up-to-date \
+view of the screen.
+</perception>
+
+<tool_use>
+Use `computer_task` to delegate desktop goals. Describe the full goal in natural language — \
+the desktop subagent handles window focus, clicking, typing, and screen reading internally.
+</tool_use>
+
+<execution_principles>
+- One `computer_task` call per distinct goal. Chain calls for multi-step workflows.
+- Prefer specific, outcome-oriented descriptions: "Save the document as report.docx" not "press Ctrl+S".
+- If a task fails, inspect the returned error and retry with a clearer description.
+</execution_principles>
+
 Example: "Open Notepad, type 'Hello World', save it as test.txt"
 
 The tool handles all the details of desktop state observation and action execution. You can chain \
@@ -69,11 +87,13 @@ def unregister_tools(self, registry: "ToolRegistry") -> None:
 
     def register_hooks(self, hooks: "Hooks") -> None:
         self._hooks = hooks
-        # Hooks are not registered to main agent (subagent manages its own state injection)
+        if self._enabled:
+            hooks.register(HookEvent.BEFORE_LLM_CALL, self._state_hook)
+            hooks.register(HookEvent.AFTER_TOOL_CALL, self._wait_for_ui_hook)
 
     def unregister_hooks(self, hooks: "Hooks") -> None:
-        # No-op: hooks were never registered to main agent
-        pass
+        hooks.unregister(HookEvent.BEFORE_LLM_CALL, self._state_hook)
+        hooks.unregister(HookEvent.AFTER_TOOL_CALL, self._wait_for_ui_hook)
 
     def attach_prompt(self, context: "Context") -> None:
         self._context = context
@@ -114,6 +134,9 @@ def _init_sync(self) -> None:
     async def enable(self) -> None:
         """Dynamically enable computer_use at runtime."""
         self._enabled = True
+        if self._hooks is not None:
+            self._hooks.register(HookEvent.BEFORE_LLM_CALL, self._state_hook)
+            self._hooks.register(HookEvent.AFTER_TOOL_CALL, self._wait_for_ui_hook)
         if self._registry is not None:
             for tool in self.get_tools():
                 if self._registry.get(tool.name) is None:
@@ -125,6 +148,8 @@ async def enable(self) -> None:
     async def disable(self) -> None:
         """Dynamically disable computer_use at runtime."""
         self._enabled = False
+        if self._hooks is not None:
+            self.unregister_hooks(self._hooks)
         if self._registry is not None:
             self.unregister_tools(self._registry)
         if self._context is not None:

operator_use/web/plugin.py

@@ -4,6 +4,7 @@
 from typing import TYPE_CHECKING
 
 from operator_use.plugins.base import Plugin
+from operator_use.agent.hooks.events import HookEvent
 
 if TYPE_CHECKING:
     from operator_use.agent.hooks import Hooks
@@ -20,6 +21,22 @@
 and the tool will run an isolated browser agent with its own context window (30-iteration budget). \
 The agent returns a summary of what was accomplished.
 
+<perception>
+Before each browser interaction, current browser state (URL, visible elements, page title) is \
+injected automatically into your context so you always have an up-to-date view of the page.
+</perception>
+
+<tool_use>
+Use `browser_task` to delegate browsing goals. Describe the full goal in natural language — \
+the browser subagent handles navigation, clicking, typing, and scraping internally.
+</tool_use>
+
+<execution_principles>
+- One `browser_task` call per distinct goal. Chain calls for multi-step workflows.
+- Prefer specific, outcome-oriented descriptions: "Find the price of X on Y" not "go to Y".
+- If a task fails, inspect the returned error and retry with a clearer description.
+</execution_principles>
+
 **Setup:**
 
 Start Chrome with remote debugging enabled:
@@ -72,17 +89,19 @@ def register_tools(self, registry: "ToolRegistry") -> None:
                 registry.register(tool)
 
     def unregister_tools(self, registry: "ToolRegistry") -> None:
+        registry.unset_extension("browser")
+        registry.unset_extension("_browser")
         for tool in self.get_tools():
             if registry.get(tool.name) is not None:
                 registry.unregister(tool.name)
 
     def register_hooks(self, hooks: "Hooks") -> None:
         self._hooks = hooks
-        # Hooks are not registered to main agent (subagent manages its own state injection)
+        if self._enabled:
+            hooks.register(HookEvent.BEFORE_LLM_CALL, self._state_hook)
 
     def unregister_hooks(self, hooks: "Hooks") -> None:
-        # No-op: hooks were never registered to main agent
-        pass
+        hooks.unregister(HookEvent.BEFORE_LLM_CALL, self._state_hook)
 
     def attach_prompt(self, context: "Context") -> None:
         self._context = context
@@ -108,6 +127,8 @@ def _init_sync(self) -> None:
     async def enable(self) -> None:
         """Dynamically enable browser_use at runtime."""
         self._enabled = True
+        if self._hooks is not None:
+            self._hooks.register(HookEvent.BEFORE_LLM_CALL, self._state_hook)
         if self._registry is not None:
             if self.browser is not None:
                 self._registry.set_extension("browser", self.browser)
@@ -122,6 +143,8 @@ async def enable(self) -> None:
     async def disable(self) -> None:
         """Dynamically disable browser_use at runtime."""
         self._enabled = False
+        if self._hooks is not None:
+            self.unregister_hooks(self._hooks)
         if self._registry is not None:
             self.unregister_tools(self._registry)
         if self._context is not None: