superbrowser-sdk 2.6.0__tar.gz → 2.7.0__tar.gz

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.7.0] — 2026-06-26
+
+### Added — MCP reload and history navigation tools (P3.0B)
+
+- `reload`, `go_back`, `go_forward` are now navigation-tier MCP tools
+  (default-allowed, not action-budgeted). Each delegates to a new thin facade
+  method that calls the underlying Playwright page method.
+- `go_back` and `go_forward` return a structured error when there is no
+  history entry to navigate to.
+- Default advertised tools: 14 → 17; action mode: 20 → 23.
+- Diagnostics remain session-wide after navigation.
+
 ## [2.6.0] — 2026-06-26
 
 ### Added — MCP switch_tab navigation tool (P3.0A)

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superbrowser-sdk
-Version: 2.6.0
+Version: 2.7.0
 Summary: Anti-detection agent browser SDK — stealth, budget governance, security guardrails, and structured error recovery behind one async facade
 Project-URL: Homepage, https://github.com/Octo-Lex/Super-Browser
 Project-URL: Documentation, https://github.com/Octo-Lex/Super-Browser#readme

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/docs/api-reference.md

@@ -101,6 +101,36 @@ if result.ok:
     print(result.data.final_url)  # "https://example.com/"
 ```
 
+#### `reload(*, wait_until="domcontentloaded") → ActionResult`
+
+Reload the current page.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `wait_until` | `str` | `"domcontentloaded"` | Playwright load event to wait for. |
+
+**Returns:** `ActionResult` with `data.url` (the page URL after reload).
+
+#### `go_back(*, wait_until="domcontentloaded") → ActionResult`
+
+Go back one step in browser history.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `wait_until` | `str` | `"domcontentloaded"` | Playwright load event to wait for. |
+
+**Returns:** `ActionResult` with `data.url`, or `ok=False` if there is no previous history entry.
+
+#### `go_forward(*, wait_until="domcontentloaded") → ActionResult`
+
+Go forward one step in browser history.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `wait_until` | `str` | `"domcontentloaded"` | Playwright load event to wait for. |
+
+**Returns:** `ActionResult` with `data.url`, or `ok=False` if there is no next history entry.
+
 ### Interaction
 
 #### `click(target, *, description=None) → ActionResult`

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/docs/mcp.md

@@ -5,8 +5,8 @@ Super Browser exposes its browser inspection and control surface over the
 agents (Claude, Cursor, etc.) can observe and interact with a page without
 scripting Python.
 
-The stdio server advertises **fourteen tools by default** (six inspect + five
-diagnostics + three navigation) — enough to read a URL end-to-end and explain
+The stdio server advertises **seventeen tools by default** (six inspect + five
+diagnostics + six navigation) — enough to read a URL end-to-end and explain
 why a read failed. When action mode is enabled, it advertises **six additional
 action tools**; every action call is checked by
 `MCPSessionPolicy` and `SecurityManager` before it can reach the browser.
@@ -31,12 +31,12 @@ python -m patchright install chromium
 Either of:
 
 ```bash
-superbrowser-mcp                       # default: 14 tools (inspect + diagnostics + navigation)
-superbrowser-mcp --allow-actions       # 20 tools (adds the action tier)
+superbrowser-mcp                       # default: 17 tools (inspect + diagnostics + navigation)
+superbrowser-mcp --allow-actions       # 23 tools (adds the action tier)
 python -m super_browser.mcp_server
 ```
 
-Both start a **stdio** server. The default server advertises 14 tools and
+Both start a **stdio** server. The default server advertises 17 tools and
 recognizes (but refuses) action-tool calls with a structured policy refusal.
 
 Action mode can also be enabled via the environment:
@@ -149,6 +149,9 @@ and do **not** require action mode.
 | `navigate` | `url` (required), `wait_until` (optional) | Go to a URL. URL is passed to `SecurityManager` for injection detection, secret redaction, and domain allow/block enforcement. |
 | `wait_for` | exactly one of `selector` / `text` / `url` / `load_state`; `timeout_ms` (optional, 100–60000, default 10000) | Wait for a page condition before the next read. |
 | `switch_tab` | `tab_id` (required, integer) | Switch the active browser tab by ID (from `list_tabs`). Changes the page the agent reads from. Diagnostics remain session-wide after switching; per-tab diagnostics are not supported yet. |
+| `reload` | `wait_until` (optional) | Reload the current page. Returns the URL after reload. |
+| `go_back` | `wait_until` (optional) | Go back one step in browser history. Returns a structured error if there is no previous entry. |
+| `go_forward` | `wait_until` (optional) | Go forward one step in browser history. Returns a structured error if there is no next entry. |
 
 `wait_for` accepts exactly one condition per call (deterministic single
 results; compound waits can be added later as an explicit AND mode).
@@ -230,7 +233,7 @@ restricts the survivors.
 
 The default server behavior partitions the surface by risk:
 
-- **`list_tools()`** advertises only the Inspect + Navigation tiers (14 tools).
+- **`list_tools()`** advertises only the Inspect + Navigation tiers (17 tools).
 - **`call_tool()`** still recognizes action-tool names and returns a structured
   policy refusal (`refusal.reason = "actions are disabled"`), not an "Unknown
   tool" error.

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "superbrowser-sdk"
-version = "2.6.0"
+version = "2.7.0"
 description = "Anti-detection agent browser SDK — stealth, budget governance, security guardrails, and structured error recovery behind one async facade"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/src/super_browser/__init__.py

@@ -6,7 +6,7 @@ from super_browser.agent.types import StreamEvent as StreamEvent  # noqa: F401
 from super_browser.config import Config as Config  # noqa: F401
 from super_browser.results.types import ActionResult as ActionResult  # noqa: F401
 
-__version__ = "2.6.0"
+__version__ = "2.7.0"
 
 __all__ = [
     "SuperBrowser",

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/src/super_browser/agent/facade.py

@@ -240,6 +240,60 @@ class SuperBrowser:
             method=ActionMethod.SELECTOR,
         )
 
+    async def reload(self, *, wait_until: str = "domcontentloaded") -> ActionResult:
+        """Reload the current page."""
+        if not self._page:
+            return action_result(ok=False, error=ActionError(ErrorCategory.BROWSER_CRASH, "Not started"))
+        params = {"wait_until": wait_until}
+        sec = await self._check_facade_security("reload", params, security_level="sensitive")
+        if sec is not None:
+            return sec
+        wait_until = params["wait_until"]
+        start = time.monotonic()
+        await self._page.backend_page.reload(wait_until=wait_until)
+        return timed_action_result(
+            ok=True, start_ns=start, data={"url": self._page.url},
+            method=ActionMethod.SELECTOR,
+        )
+
+    async def go_back(self, *, wait_until: str = "domcontentloaded") -> ActionResult:
+        """Navigate to the previous page in browser history."""
+        if not self._page:
+            return action_result(ok=False, error=ActionError(ErrorCategory.BROWSER_CRASH, "Not started"))
+        params = {"wait_until": wait_until}
+        sec = await self._check_facade_security("go_back", params, security_level="sensitive")
+        if sec is not None:
+            return sec
+        wait_until = params["wait_until"]
+        start = time.monotonic()
+        response = await self._page.backend_page.go_back(wait_until=wait_until)
+        if response is None:
+            return action_result(ok=False, error=ActionError(
+                ErrorCategory.PAGE_ERROR, "No history entry to go back to"))
+        return timed_action_result(
+            ok=True, start_ns=start, data={"url": self._page.url},
+            method=ActionMethod.SELECTOR,
+        )
+
+    async def go_forward(self, *, wait_until: str = "domcontentloaded") -> ActionResult:
+        """Navigate to the next page in browser history."""
+        if not self._page:
+            return action_result(ok=False, error=ActionError(ErrorCategory.BROWSER_CRASH, "Not started"))
+        params = {"wait_until": wait_until}
+        sec = await self._check_facade_security("go_forward", params, security_level="sensitive")
+        if sec is not None:
+            return sec
+        wait_until = params["wait_until"]
+        start = time.monotonic()
+        response = await self._page.backend_page.go_forward(wait_until=wait_until)
+        if response is None:
+            return action_result(ok=False, error=ActionError(
+                ErrorCategory.PAGE_ERROR, "No history entry to go forward to"))
+        return timed_action_result(
+            ok=True, start_ns=start, data={"url": self._page.url},
+            method=ActionMethod.SELECTOR,
+        )
+
     async def click(self, target: str, *, description: Optional[str] = None) -> ActionResult:
         if not self._controller:
             return action_result(ok=False, error=ActionError(ErrorCategory.BROWSER_CRASH, "Browser not started. Call await sb.start() first."))

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/src/super_browser/mcp_server.py

@@ -141,6 +141,51 @@ NAVIGATION_AUX_TOOLS: list[types.Tool] = [
             "required": ["tab_id"],
         },
     ),
+    types.Tool(
+        name="reload",
+        description="Reload the current page. Navigation-tier tool (default-allowed).",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "wait_until": {
+                    "type": "string",
+                    "enum": ["load", "domcontentloaded", "networkidle"],
+                    "default": "domcontentloaded",
+                },
+            },
+            "required": [],
+        },
+    ),
+    types.Tool(
+        name="go_back",
+        description="Go back one step in browser history. Navigation-tier tool (default-allowed).",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "wait_until": {
+                    "type": "string",
+                    "enum": ["load", "domcontentloaded", "networkidle"],
+                    "default": "domcontentloaded",
+                },
+            },
+            "required": [],
+        },
+    ),
+    types.Tool(
+        name="go_forward",
+        description="Go forward one step in browser history. Navigation-tier tool (default-allowed).",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "wait_until": {
+                    "type": "string",
+                    "enum": ["load", "domcontentloaded", "networkidle"],
+                    "default": "domcontentloaded",
+                },
+            },
+            "required": [],
+        },
+    ),
 ]
 
 _NAVIGATION_AUX_TOOL_NAMES = frozenset(t.name for t in NAVIGATION_AUX_TOOLS)
@@ -924,6 +969,15 @@ class ToolDispatcher:
                 )
             return None
 
+        if name in ("reload", "go_back", "go_forward"):
+            wait_until = arguments.get("wait_until", "domcontentloaded")
+            if wait_until not in ("load", "domcontentloaded", "networkidle"):
+                return _error_content(
+                    "'wait_until' must be one of: load, domcontentloaded, networkidle",
+                    kind="invalid_arguments",
+                )
+            return None
+
         if name == "wait_for":
             # timeout_ms: integer, 100 <= x <= 60000. Reject bool (int subtype).
             timeout_ms = arguments.get("timeout_ms", 10000)
@@ -1048,6 +1102,21 @@ class ToolDispatcher:
         ar = await sb.switch_tab(arguments["tab_id"])
         return _text_content(_serialize_action_result(ar))
 
+    async def _tool_reload(self, arguments: dict[str, Any]) -> list[types.TextContent]:
+        sb = await self.runtime.get_browser()
+        ar = await sb.reload(wait_until=arguments.get("wait_until", "domcontentloaded"))
+        return _text_content(_serialize_action_result(ar))
+
+    async def _tool_go_back(self, arguments: dict[str, Any]) -> list[types.TextContent]:
+        sb = await self.runtime.get_browser()
+        ar = await sb.go_back(wait_until=arguments.get("wait_until", "domcontentloaded"))
+        return _text_content(_serialize_action_result(ar))
+
+    async def _tool_go_forward(self, arguments: dict[str, Any]) -> list[types.TextContent]:
+        sb = await self.runtime.get_browser()
+        ar = await sb.go_forward(wait_until=arguments.get("wait_until", "domcontentloaded"))
+        return _text_content(_serialize_action_result(ar))
+
     async def _tool_wait_for(self, arguments: dict[str, Any]) -> list[types.TextContent]:
         """Wait for exactly one page condition (selector/text/url/load_state).
 

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/tests/test_mcp_diagnostics.py

@@ -75,16 +75,16 @@ class TestDiagnosticsAdvertisement:
         from super_browser.mcp_server import MCPSessionPolicy, _tools_for_policy
 
         names = {t.name for t in _tools_for_policy(MCPSessionPolicy())}
-        assert len(names) == 14
+        assert len(names) == 17
         for diag in ("get_console_messages", "get_page_errors", "get_network_errors",
                      "list_requests", "get_request"):
             assert diag in names
 
-    def test_action_mode_advertises_20_tools(self):
+    def test_action_mode_advertises_23_tools(self):
         from super_browser.mcp_server import MCPSessionPolicy, _tools_for_policy
 
         names = {t.name for t in _tools_for_policy(MCPSessionPolicy(allow_actions=True))}
-        assert len(names) == 20
+        assert len(names) == 23
 
     def test_diagnostics_are_inspect_tier(self):
         """Diagnostics tools are in INSPECT_TOOL_NAMES (no action gate)."""

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/tests/test_mcp_navigation.py

@@ -35,10 +35,10 @@ class TestTierConstants:
             "get_network_errors", "list_requests", "get_request",
         })
 
-    def test_navigation_tool_names_has_two_tools(self):
+    def test_navigation_tool_names_has_six_tools(self):
         from super_browser.mcp_server import NAVIGATION_TOOL_NAMES
 
-        assert NAVIGATION_TOOL_NAMES == frozenset({"navigate", "wait_for", "switch_tab"})
+        assert NAVIGATION_TOOL_NAMES == frozenset({"navigate", "wait_for", "switch_tab", "reload", "go_back", "go_forward"})
 
     def test_action_tool_names_has_six_tools(self):
         from super_browser.mcp_server import ACTION_TOOL_NAMES
@@ -77,7 +77,7 @@ class TestTierConstants:
 
         all_known = {
             "browser_status", "current_url", "observe", "extract_text",
-            "screenshot", "list_tabs", "navigate", "wait_for", "switch_tab",
+            "screenshot", "list_tabs", "navigate", "wait_for", "switch_tab", "reload", "go_back", "go_forward",
             "scroll", "press_key", "click", "fill", "open_tab", "close_tab",
             "get_console_messages", "get_page_errors", "get_network_errors",
             "list_requests", "get_request",
@@ -658,7 +658,7 @@ class TestToolAdvertisement:
 
         advertised = _tools_for_policy(MCPSessionPolicy())
         names = {t.name for t in advertised}
-        assert len(advertised) == 14
+        assert len(advertised) == 17
         # All 5 diagnostics tools present.
         assert {"get_console_messages", "get_page_errors", "get_network_errors",
                 "list_requests", "get_request"} <= names
@@ -676,12 +676,12 @@ class TestToolAdvertisement:
         assert {t.name for t in advertised} == DEFAULT_TOOL_NAMES
         assert DEFAULT_TOOL_NAMES == INSPECT_TOOL_NAMES | NAVIGATION_TOOL_NAMES
 
-    def test_allow_actions_advertises_20_tools(self):
+    def test_allow_actions_advertises_23_tools(self):
         from super_browser.mcp_server import MCPSessionPolicy, _tools_for_policy
 
         advertised = _tools_for_policy(MCPSessionPolicy(allow_actions=True))
         names = {t.name for t in advertised}
-        assert len(advertised) == 20
+        assert len(advertised) == 23
         # All 6 action tools present.
         assert {"scroll", "press_key", "click", "fill", "open_tab", "close_tab"} <= names
 
@@ -697,28 +697,28 @@ class TestToolAdvertisement:
         server = build_server()
         policy = server._sb_policy  # type: ignore[attr-defined]
         names = {t.name for t in _tools_for_policy(policy)}
-        assert len(names) == 14
+        assert len(names) == 17
         assert "navigate" in names
         assert "wait_for" in names
         assert "get_console_messages" in names
         assert "click" not in names
 
-    def test_build_server_allow_actions_advertises_20(self):
+    def test_build_server_allow_actions_advertises_23(self):
         from super_browser.mcp_server import MCPSessionPolicy, _tools_for_policy, build_server
 
         server = build_server(policy=MCPSessionPolicy(allow_actions=True))
         policy = server._sb_policy  # type: ignore[attr-defined]
         names = {t.name for t in _tools_for_policy(policy)}
-        assert len(names) == 20
+        assert len(names) == 23
 
-    def test_build_server_legacy_allow_writes_advertises_20(self):
+    def test_build_server_legacy_allow_writes_advertises_23(self):
         """Legacy allow_writes=True must still enable action tools."""
         from super_browser.mcp_server import MCPSessionPolicy, _tools_for_policy, build_server
 
         server = build_server(policy=MCPSessionPolicy(allow_writes=True))
         policy = server._sb_policy  # type: ignore[attr-defined]
         names = {t.name for t in _tools_for_policy(policy)}
-        assert len(names) == 20
+        assert len(names) == 23
 
 
 # ============================================================================
@@ -1163,3 +1163,159 @@ class TestSwitchTabTool:
         result = await dispatcher.dispatch("switch_tab", {"tab_id": 999})
         payload = json.loads(result[0].text)
         assert payload["ok"] is False
+
+
+# ============================================================================
+# reload / go_back / go_forward (P3.0B) — navigation-tier MCP tools
+# ============================================================================
+
+
+class TestHistoryNavigationTools:
+    """reload, go_back, go_forward are navigation-tier: default-allowed,
+    delegate to the facade, don't consume action budget."""
+
+    def test_all_three_in_navigation_tool_names(self):
+        from super_browser.mcp_server import NAVIGATION_TOOL_NAMES
+
+        for name in ("reload", "go_back", "go_forward"):
+            assert name in NAVIGATION_TOOL_NAMES
+
+    def test_all_three_in_default_advertised_tools(self):
+        from super_browser.mcp_server import MCPSessionPolicy, _tools_for_policy
+
+        names = {t.name for t in _tools_for_policy(MCPSessionPolicy())}
+        for name in ("reload", "go_back", "go_forward"):
+            assert name in names
+
+    @pytest.mark.asyncio
+    async def test_reload_dispatches_to_facade(self):
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        fake_sb.reload = AsyncMock(return_value=_fake_action_result({"url": "https://example.com"}))
+        result = await dispatcher.dispatch("reload", {})
+        fake_sb.reload.assert_awaited_once()
+        payload = json.loads(result[0].text)
+        assert payload["ok"] is True
+
+    @pytest.mark.asyncio
+    async def test_go_back_dispatches_to_facade(self):
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        fake_sb.go_back = AsyncMock(return_value=_fake_action_result({"url": "https://prev.com"}))
+        result = await dispatcher.dispatch("go_back", {})
+        fake_sb.go_back.assert_awaited_once()
+        assert json.loads(result[0].text)["ok"] is True
+
+    @pytest.mark.asyncio
+    async def test_go_forward_dispatches_to_facade(self):
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        fake_sb.go_forward = AsyncMock(return_value=_fake_action_result({"url": "https://next.com"}))
+        result = await dispatcher.dispatch("go_forward", {})
+        fake_sb.go_forward.assert_awaited_once()
+        assert json.loads(result[0].text)["ok"] is True
+
+    @pytest.mark.asyncio
+    async def test_passes_wait_until(self):
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        fake_sb.reload = AsyncMock(return_value=_fake_action_result({"url": "x"}))
+        await dispatcher.dispatch("reload", {"wait_until": "networkidle"})
+        fake_sb.reload.assert_awaited_once_with(wait_until="networkidle")
+
+    @pytest.mark.asyncio
+    async def test_invalid_wait_until_returns_error(self):
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        fake_sb.reload = AsyncMock()
+        result = await dispatcher.dispatch("reload", {"wait_until": "bogus"})
+        payload = json.loads(result[0].text)
+        assert payload["ok"] is False
+        assert "invalid_arguments" in payload
+        fake_sb.reload.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_do_not_require_allow_actions(self):
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        for name, mock_name in [("reload", "reload"), ("go_back", "go_back"), ("go_forward", "go_forward")]:
+            setattr(fake_sb, mock_name, AsyncMock(return_value=_fake_action_result({"url": "x"})))
+            result = await dispatcher.dispatch(name, {})
+            assert json.loads(result[0].text)["ok"] is True
+
+    @pytest.mark.asyncio
+    async def test_do_not_increment_actions_used(self):
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        fake_sb.reload = AsyncMock(return_value=_fake_action_result({"url": "x"}))
+        fake_sb.go_back = AsyncMock(return_value=_fake_action_result({"url": "x"}))
+        fake_sb.go_forward = AsyncMock(return_value=_fake_action_result({"url": "x"}))
+        await dispatcher.dispatch("reload", {})
+        await dispatcher.dispatch("go_back", {})
+        await dispatcher.dispatch("go_forward", {})
+        assert dispatcher.authorizer.policy.actions_used == 0
+
+    @pytest.mark.asyncio
+    async def test_facade_error_returns_structured(self):
+        """When facade returns ok=False (e.g. no history), MCP reflects it."""
+        dispatcher, fake_sb = _make_dispatcher(allow_actions=False)
+        err_result = MagicMock()
+        err_result.ok = False
+        err_result.data = None
+        err_result.error = {"category": "page_error", "message": "No history entry"}
+        err_result.meta = None
+        fake_sb.go_back = AsyncMock(return_value=err_result)
+        result = await dispatcher.dispatch("go_back", {})
+        payload = json.loads(result[0].text)
+        assert payload["ok"] is False
+
+
+# ============================================================================
+# Facade security blocking (P3.0B review) — backend page not called when blocked
+# ============================================================================
+
+
+class TestFacadeSecurityBlocking:
+    """The new facade methods (reload/go_back/go_forward) must call
+    _check_facade_security before touching the backend page. When security
+    blocks, the backend method must never be awaited."""
+
+    def _blocked_sb(self):
+        """A SuperBrowser whose _check_facade_security always returns a denial."""
+        from super_browser import SuperBrowser
+        from super_browser.results.types import ActionError, ErrorCategory, action_result
+
+        sb = SuperBrowser()
+        # Pre-seed a fake page so the _page check passes.
+        sb._page = MagicMock()
+        sb._page.url = "https://example.com"
+        sb._page.backend_page = MagicMock()
+        sb._page.backend_page.reload = AsyncMock()
+        sb._page.backend_page.go_back = AsyncMock()
+        sb._page.backend_page.go_forward = AsyncMock()
+        # Make _check_facade_security return a denial (not None).
+        sb._check_facade_security = AsyncMock(return_value=action_result(
+            ok=False, error=ActionError(ErrorCategory.SECURITY, "blocked")))
+        return sb
+
+    @pytest.mark.asyncio
+    async def test_reload_blocked_does_not_call_backend(self):
+        sb = self._blocked_sb()
+        result = await sb.reload()
+        assert result.ok is False
+        sb._page.backend_page.reload.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_go_back_blocked_does_not_call_backend(self):
+        sb = self._blocked_sb()
+        result = await sb.go_back()
+        assert result.ok is False
+        sb._page.backend_page.go_back.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_go_forward_blocked_does_not_call_backend(self):
+        sb = self._blocked_sb()
+        result = await sb.go_forward()
+        assert result.ok is False
+        sb._page.backend_page.go_forward.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_check_facade_security_is_called_for_all_three(self):
+        sb = self._blocked_sb()
+        await sb.reload()
+        await sb.go_back()
+        await sb.go_forward()
+        assert sb._check_facade_security.call_count == 3

{superbrowser_sdk-2.6.0 → superbrowser_sdk-2.7.0}/tests/test_mcp_server.py

@@ -40,8 +40,8 @@ INSPECT_TOOL_NAMES = {
     "list_requests", "get_request",
 }
 # Navigation-tier tool set (always advertised).
-NAVIGATION_TOOL_NAMES = {"navigate", "wait_for", "switch_tab"}
-# Default advertised set: Inspect + Navigation (14 tools).
+NAVIGATION_TOOL_NAMES = {"navigate", "wait_for", "switch_tab", "reload", "go_back", "go_forward"}
+# Default advertised set: Inspect + Navigation (17 tools).
 DEFAULT_TOOL_NAMES = INSPECT_TOOL_NAMES | NAVIGATION_TOOL_NAMES
 # Action-tier tool set (advertised only when allow_actions=True).
 ACTION_TOOL_NAMES = {
@@ -437,7 +437,7 @@ class TestServerWiring:
         advertised = _tools_for_policy(policy)
         advertised_names = {t.name for t in advertised}
         assert advertised_names == DEFAULT_TOOL_NAMES
-        assert len(advertised) == 14
+        assert len(advertised) == 17
 
     def test_actions_enabled_server_advertises_exactly_19_tools(self):
         """build_server(policy=allow_actions=True) advertises all 19 tools,
@@ -449,7 +449,7 @@ class TestServerWiring:
         advertised = _tools_for_policy(policy)
         advertised_names = {t.name for t in advertised}
         assert advertised_names == ALL_TOOL_NAMES
-        assert len(advertised) == 20
+        assert len(advertised) == 23
 
     @pytest.mark.asyncio
     async def test_default_server_dispatch_returns_refusal_not_unknown(self):