Skip to content

The agent that grows with you

refactor(browser): callers import the browser_session layer

Tekniumd6a5251d9303
diff --git a/agent/chat_completion_helpers.py b/agent/chat_completion_helpers.py
index dcb93af1809..4e2327d6926 100644
--- a/agent/chat_completion_helpers.py
+++ b/agent/chat_completion_helpers.py
@@ -2337,11 +2337,8 @@ def cleanup_task_resources(agent, task_id: str) -> None:
terminal envs (``_cleanup_inactive_envs`` reaps them after ``terminal.lifetime_seconds``)
and ``cleanup_browser`` in headed mode (the inactivity reaper handles idle sessions)."""
def _headed() -> bool:
- try:
- from tools.browser_tool_cloud import _is_headed_mode
- return _is_headed_mode()
- except Exception:
- return bool(os.environ.get("AGENT_BROWSER_HEADED"))
+ from tools.browser_session_cloud import is_headed_mode
+ return is_headed_mode()
for label, skip, skip_what, cleanup in (
("VM", is_persistent_env, "cleanup_vm for persistent env", lambda: _ra().cleanup_vm(task_id)),
diff --git a/cli.py b/cli.py
index 02d5146c4e6..f4224111729 100644
--- a/cli.py
+++ b/cli.py
@@ -407,7 +407,7 @@ _cleanup_all_terminals = _lazy_shim("tools.terminal_tool", "cleanup_all_environm
set_sudo_password_callback = _lazy_shim("tools.terminal_tool", "set_sudo_password_callback")
set_approval_callback = _lazy_shim("tools.terminal_tool", "set_approval_callback")
set_secret_capture_callback = _lazy_shim("tools.skills_tool", "set_secret_capture_callback")
-_cleanup_all_browsers = _lazy_shim("tools.browser_tool_lifecycle", "_emergency_cleanup_all_sessions", "_cleanup_all_browsers")
+_cleanup_all_browsers = _lazy_shim("tools.browser_session_lifecycle", "emergency_cleanup_all_sessions", "_cleanup_all_browsers")
_cleanup_done = False # _run_cleanup runs exactly once
_cleanup_in_progress = False
diff --git a/gateway/run_shutdown.py b/gateway/run_shutdown.py
index 9cc69130b55..2ba066193f4 100644
--- a/gateway/run_shutdown.py
+++ b/gateway/run_shutdown.py
@@ -1794,7 +1794,7 @@ class GatewayShutdownMixin(GatewaySessionEndMixin):
cleanup_all_environments()
def _cleanup_browsers() -> None:
- from tools.browser_tool_lifecycle import cleanup_all_browsers
+ from tools.browser_session_lifecycle import cleanup_all_browsers
cleanup_all_browsers()
_step("cleanup_all_environments", _cleanup_environments)
diff --git a/hermes_cli/cli_commands_mixin.py b/hermes_cli/cli_commands_mixin.py
index 01f0394fa42..f05679db55f 100644
--- a/hermes_cli/cli_commands_mixin.py
+++ b/hermes_cli/cli_commands_mixin.py
@@ -233,9 +233,9 @@ def _refresh_tui_before_print(cli) -> None:
def _print_lightpanda_engine_status() -> None:
"""``/browser status`` line(s) about ``browser.engine: lightpanda`` — silent unless set;
says whether it is in use or which higher-precedence setting shadows it."""
- if not _probe("tools.browser_tool_lightpanda_fallback", "_using_lightpanda_engine", False):
+ if not _probe("tools.browser_lightpanda", "using_lightpanda_engine", False):
return
- used, reason = _probe("tools.browser_tool_lightpanda_fallback", "lightpanda_engine_status", (None, None))
+ used, reason = _probe("tools.browser_lightpanda", "lightpanda_engine_status", (None, None))
if reason is None:
return
if not used:
@@ -290,7 +290,7 @@ def _browser_connect(cli, cdp_url: str) -> None:
return
cdp_url, port = normalized
# Clear any existing browser sessions so the next tool call uses the new backend
- _probe("tools.browser_tool_lifecycle", "cleanup_all_browsers", None)
+ _probe("tools.browser_session_lifecycle", "cleanup_all_browsers", None)
print()
# Already serving CDP? For the default-local URL probe both loopbacks: a squatter
# on 127.0.0.1:<port> (e.g. an IDE debugger) can push the browser to bind [::1] only.
@@ -309,7 +309,7 @@ def _browser_connect(cli, cdp_url: str) -> None:
return _say_block(_t("browser.not_connected"))
os.environ["BROWSER_CDP_URL"] = found
# Eagerly start the CDP supervisor so pending_dialogs + frame_tree show up in the next snapshot.
- _probe("tools.browser_tool_cdp", "_ensure_cdp_supervisor", None, "default")
+ _probe("tools.browser_session_cdp", "ensure_cdp_supervisor", None, "default")
_say_block(_t("browser.connected"), f" {_t('browser.endpoint', url=found)}")
# Tell the model the CDP browser was made available on purpose.
if hasattr(cli, '_pending_input'):
@@ -330,9 +330,9 @@ def _browser_disconnect(cli) -> None:
return _say_block(_t("browser.already_default"))
os.environ.pop("BROWSER_CDP_URL", None)
with suppress(Exception):
- from tools.browser_tool_lifecycle import cleanup_all_browsers
- from tools.browser_tool_cdp import _stop_cdp_supervisor
- _stop_cdp_supervisor("default")
+ from tools.browser_session_lifecycle import cleanup_all_browsers
+ from tools.browser_session_cdp import stop_cdp_supervisor
+ stop_cdp_supervisor("default")
cleanup_all_browsers()
_say_block(_t("browser.disconnected"), f" {_t('browser.reverted')}")
if hasattr(cli, '_pending_input'):
@@ -369,12 +369,12 @@ def _browser_status() -> None:
except Exception:
print(f" {_t('browser.status_unreachable')}")
else:
- provider = _probe("tools.browser_tool_cloud", "_get_cloud_provider", None)
+ provider = _probe("tools.browser_session_cloud", "get_cloud_provider", None)
if provider is not None:
print(_t("browser.status_cloud", provider=provider.display_name))
_print_lightpanda_engine_status()
else:
- engine = _probe("tools.browser_tool_cloud", "_get_browser_engine", "auto")
+ engine = _probe("tools.browser_session_cloud", "get_browser_engine", "auto")
_pr(*_local_engine_lines(engine))
if engine == "lightpanda":
_print_lightpanda_engine_status()
diff --git a/hermes_cli/main.py b/hermes_cli/main.py
index 03f6c60555f..e5384f28173 100644
--- a/hermes_cli/main.py
+++ b/hermes_cli/main.py
@@ -103,7 +103,7 @@ _oneshot_cleanup_done = False
_ONESHOT_CLEANUPS = (
("tools.terminal_tool", "cleanup_all_environments", {}, Exception),
("tools.async_delegation", "interrupt_all", {"reason": "oneshot shutdown"}, Exception),
- ("tools.browser_tool_lifecycle", "_emergency_cleanup_all_sessions", {}, Exception),
+ ("tools.browser_session_lifecycle", "emergency_cleanup_all_sessions", {}, Exception),
("tools.mcp_tool_lifecycle", "shutdown_mcp_servers", {}, BaseException),
("agent.auxiliary_client", "shutdown_cached_clients", {}, Exception),
# A no-op unless this run booted the managed llama-server (atexit's hook is skipped here).
diff --git a/run_agent.py b/run_agent.py
index eda287031f8..8d7d4874c1c 100644
--- a/run_agent.py
+++ b/run_agent.py
@@ -103,7 +103,7 @@ if not _loaded_env_paths:
from model_tools import get_toolset_for_tool
from tools.terminal_tool_lifecycle import cleanup_vm, get_active_env
from tools.interrupt import set_interrupt as _set_interrupt
-from tools.browser_tool_lifecycle import cleanup_browser
+from tools.browser_session_lifecycle import cleanup_browser
from tools.connectors.turn import agent_connection_surface, scoped_connection_surface
from agent.memory_provider import is_trivial_prompt
diff --git a/tests/agent/test_cleanup_task_resources_headed.py b/tests/agent/test_cleanup_task_resources_headed.py
new file mode 100644
index 00000000000..d52c7362d1c
--- /dev/null
+++ b/tests/agent/test_cleanup_task_resources_headed.py
@@ -0,0 +1,41 @@
+"""Per-turn browser cleanup skips headed sessions by ``browser.headed`` (config) alone.
+
+The idle reaper owns a headed browser the user may be watching; the retired ``AGENT_BROWSER_HEADED``
+env var no longer keeps a headless session alive past the turn.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from agent.chat_completion_helpers import cleanup_task_resources
+from hermes_constants import reset_hermes_home_override, set_hermes_home_override
+
+
+def run(tmp_path, monkeypatch):
+ import run_agent
+
+ closed = []
+ monkeypatch.setattr(run_agent, "cleanup_browser", closed.append)
+ monkeypatch.setattr(run_agent, "cleanup_vm", lambda task_id: None)
+
+ def go(config_text: str) -> list:
+ (tmp_path / "config.yaml").write_text(config_text, encoding="utf-8")
+ token = set_hermes_home_override(str(tmp_path))
+ try:
+ cleanup_task_resources(SimpleNamespace(verbose_logging=False), "task-1")
+ finally:
+ reset_hermes_home_override(token)
+ return closed
+
+ return go
+
+
+def test_headed_config_keeps_the_browser_for_the_reaper(run):
+ assert run("browser:\n headed: true\n") == []
+
+
+def test_headless_session_closes_even_with_the_retired_env_var(run, monkeypatch):
+ monkeypatch.setenv("AGENT_BROWSER_HEADED", "1")
+ assert run("browser:\n headed: false\n") == ["task-1"]
diff --git a/tests/agent/test_treekill_consolidation.py b/tests/agent/test_treekill_consolidation.py
index 170b12f3016..38ec418c069 100644
--- a/tests/agent/test_treekill_consolidation.py
+++ b/tests/agent/test_treekill_consolidation.py
@@ -7,7 +7,6 @@ termination through :func:`agent.deadline.kill_process_tree`:
* ``hermes_cli._subprocess_compat.kill_process_tree(proc)`` — also consumed
by ``agent.shell_hooks`` by name; falls back to
``_legacy_kill_process_tree`` when delegation fails.
-* ``tools.browser_tool_lifecycle._kill_process_tree(proc)`` — same pattern.
* ``tools.code_execution_tool._kill_process_group(proc, escalate=...)`` —
SIGTERM tree first, then (escalate) bounded wait + SIGKILL tree.
@@ -44,13 +43,7 @@ class _FakeProc:
# ---------------------------------------------------------------------------
-# (2) tools.browser_tool_lifecycle._kill_process_tree
-# ---------------------------------------------------------------------------
-
-
-
-# ---------------------------------------------------------------------------
-# (3) tools.code_execution_tool._kill_process_group
+# (2) tools.code_execution_tool._kill_process_group
# ---------------------------------------------------------------------------
class TestCodeExecutionDelegation:
diff --git a/tests/agent/test_vision_routing.py b/tests/agent/test_vision_routing.py
index 9f1ec370e27..5f52719d56c 100644
--- a/tests/agent/test_vision_routing.py
+++ b/tests/agent/test_vision_routing.py
@@ -19,8 +19,7 @@ The three fixes covered here:
reports ``supports_vision=False`` instead of routing image content to
a text-only endpoint.
3. ``check_vision_requirements`` mirrors the runtime fallback chain so
- ``vision_analyze`` shows up whenever the auto chain can serve vision,
- and ``browser_vision`` gates on vision availability as well.
+ ``vision_analyze`` shows up whenever the auto chain can serve vision.
"""
from __future__ import annotations
@@ -31,7 +30,6 @@ import sys
import tempfile
import pytest
-from tools import browser_tool_install as bt_install
# ---------------------------------------------------------------------------
@@ -62,8 +60,7 @@ def _write_config(home: str, text: str) -> None:
_RELOAD_PREFIXES = ("agent.auxiliary_client", "agent.image_routing",
- "tools.vision_tools", "tools.browser_tool",
- "hermes_cli.config")
+ "tools.vision_tools", "hermes_cli.config")
def _drop_reload_targets():
@@ -217,7 +214,7 @@ model:
# ---------------------------------------------------------------------------
-# Fix 3: check_vision_requirements + check_browser_vision_requirements parity
+# Fix 3: check_vision_requirements gating
# ---------------------------------------------------------------------------
@@ -243,24 +240,9 @@ auxiliary:
- def test_browser_vision_true_when_both_available(self, isolated_home, monkeypatch):
- from unittest.mock import patch
-
- _write_config(isolated_home, """
-model:
- provider: openrouter
- default: anthropic/claude-sonnet-4
-""")
- monkeypatch.setenv("OPENROUTER_API_KEY", "sk-or-test")
- _fresh_modules()
-
- import tools.browser_tool
- with patch.object(bt_install, "check_browser_requirements", return_value=True):
- assert tools.browser_tool_install.check_browser_vision_requirements() is True
-
def test_native_vision_main_advertises_image_tools_but_not_video(self, isolated_home, monkeypatch):
"""A vision-capable main model on a provider the aux resolver cannot serve (OAuth, local vLLM)
- still gets vision_analyze and browser_vision — both handlers attach pixels natively — while
+ still gets vision_analyze — its handler attaches pixels natively — while
video_analyze, whose handler has no native path, stays hidden (#47149)."""
from unittest.mock import patch
@@ -272,11 +254,8 @@ model:
""")
_fresh_modules()
- import tools.browser_tool_install as bt_install
from tools import vision_tools
- with patch.object(vision_tools, "_should_use_native_vision_fast_path", return_value=True), \
- patch.object(bt_install, "check_browser_requirements", return_value=True):
+ with patch.object(vision_tools, "_should_use_native_vision_fast_path", return_value=True):
assert vision_tools.check_video_requirements() is False # no aux client resolves
assert vision_tools.check_vision_requirements() is True
- assert bt_install.check_browser_vision_requirements() is True
diff --git a/tests/agent/transports/test_hermes_tools_mcp_server.py b/tests/agent/transports/test_hermes_tools_mcp_server.py
index 30be55bc991..1d25db5abed 100644
--- a/tests/agent/transports/test_hermes_tools_mcp_server.py
+++ b/tests/agent/transports/test_hermes_tools_mcp_server.py
@@ -94,6 +94,15 @@ class TestModuleSurface:
)
+ def test_every_exposed_tool_is_a_core_registered_tool(self):
+ """Each exposed name must dispatch through handle_function_call in a plain Hermes process:
+ a name only a plugin registers (the camofox plugin's browser_navigate & co.) is not core."""
+ import model_tools
+ from agent.transports.hermes_tools_mcp_server import EXPOSED_TOOLS
+ missing = set(EXPOSED_TOOLS) - set(model_tools.get_all_tool_names())
+ assert not missing, f"EXPOSED_TOOLS names no core tool registers: {sorted(missing)}"
+
+
class TestMain:
def test_main_returns_2_when_mcp_unavailable(self, monkeypatch):
"""When the mcp package isn't installed, main() should exit
diff --git a/tests/gateway/fixtures/browser_scope_peer.py b/tests/gateway/fixtures/browser_scope_peer.py
index 85c00f8ded8..735ecc9bea0 100644
--- a/tests/gateway/fixtures/browser_scope_peer.py
+++ b/tests/gateway/fixtures/browser_scope_peer.py
@@ -27,7 +27,7 @@ async def probe():
from hermes_cli import web_server
from hermes_cli.dashboard_auth.ws_tickets import mint_ticket
from tests.gateway.fixtures.local_recovery_probe import rpc
- import tools.browser_tool_lifecycle as lifecycle
+ import tools.browser_session_lifecycle as lifecycle
from websockets.asyncio.client import connect
home = Path(os.environ['HERMES_HOME'])
@@ -45,11 +45,11 @@ async def probe():
(bee / 'config.yaml').write_text('browser:\n cdp_url: ws://bee.invalid/devtools/browser/PROFILE-B\n')
from gateway.run import _profile_runtime_scope
from hermes_constants import hermes_home_key
- from tools import browser_tool_cdp
+ from tools import browser_session_cdp
def resolved(profile):
with _profile_runtime_scope(profile, hydrate_secrets=False):
- return browser_tool_cdp._get_cdp_override_raw()
+ return browser_session_cdp.get_cdp_override_raw()
receipt = {'home_key': hermes_home_key(home)}
cdp = ThreadingHTTPServer(('127.0.0.1', 0), _Cdp)
threading.Thread(target=cdp.serve_forever, daemon=True).start()
@@ -66,7 +66,7 @@ async def probe():
runner.session_authorities = types.SimpleNamespace(
serving=lambda: [runner.session_authority, other], multiplexed=True)
with _profile_runtime_scope(bee, hydrate_secrets=False):
- browser_tool_cdp.set_live_cdp_override('http://127.0.0.1:9444')
+ browser_session_cdp.set_live_cdp_override('http://127.0.0.1:9444')
reaps.clear()
for action, extra in [('connect', {'url': f'http://127.0.0.1:{cdp.server_port}'}),
('status', {}), ('disconnect', {}), (None, {})]:
@@ -75,7 +75,7 @@ async def probe():
receipt[f"{phase}:{action or 'missing'}"] = {
'code': reply.get('error', {}).get('code'), 'result': reply.get('result'),
'env': os.environ.get('BROWSER_CDP_URL'), 'reaps': list(reaps),
- 'own': browser_tool_cdp._live_overrides.get(receipt['home_key']),
+ 'own': browser_session_cdp._live_overrides.get(receipt['home_key']),
'bee': resolved(bee), 'cdp_port': cdp.server_port}
runner.session_authorities = real
finally:
diff --git a/tests/gateway/test_agent_cache.py b/tests/gateway/test_agent_cache.py
index 2ee30833283..9ad4c70a290 100644
--- a/tests/gateway/test_agent_cache.py
+++ b/tests/gateway/test_agent_cache.py
@@ -14,7 +14,7 @@ from unittest.mock import MagicMock, patch
import pytest
from hermes_cli.config import DEFAULT_CONFIG, cfg_get
-from tools import browser_tool_lifecycle as bt_lifecycle
+from tools import browser_session_lifecycle as bt_lifecycle
def _make_runner():
"""Create a minimal GatewayRunner with just the cache infrastructure."""
diff --git a/tests/gateway/test_api_server_active_work_drain.py b/tests/gateway/test_api_server_active_work_drain.py
index ebd86c1e190..99ac508efeb 100644
--- a/tests/gateway/test_api_server_active_work_drain.py
+++ b/tests/gateway/test_api_server_active_work_drain.py
@@ -24,7 +24,7 @@ from gateway.platforms.api_server_run_idempotency import RunIdempotencyStore
from gateway.run import _INTERRUPT_REASON_GATEWAY_SHUTDOWN
from hermes_state import SessionDB
from tests.gateway.restart_test_helpers import make_restart_runner
-from tools import browser_tool_lifecycle as bt_lifecycle
+from tools import browser_session_lifecycle as bt_lifecycle
# Safety net so a regression parks the executor thread forever instead of
# hanging CI. No assertion below depends on elapsed time.
diff --git a/tests/gateway/test_clean_shutdown_marker.py b/tests/gateway/test_clean_shutdown_marker.py
index e9dca67cb46..5bf48ae4009 100644
--- a/tests/gateway/test_clean_shutdown_marker.py
+++ b/tests/gateway/test_clean_shutdown_marker.py
@@ -67,7 +67,7 @@ class TestCleanShutdownMarker:
patch("gateway.status.remove_pid_file"), \
patch("tools.process_registry.process_registry") as mock_proc_reg, \
patch("tools.terminal_tool.cleanup_all_environments"), \
- patch("tools.browser_tool_lifecycle.cleanup_all_browsers"):
+ patch("tools.browser_session_lifecycle.cleanup_all_browsers"):
mock_proc_reg.kill_all = MagicMock()
import asyncio
diff --git a/tests/gateway/test_cron_active_work_drain.py b/tests/gateway/test_cron_active_work_drain.py
index 30f27b6cc56..7f2d9f46b12 100644
--- a/tests/gateway/test_cron_active_work_drain.py
+++ b/tests/gateway/test_cron_active_work_drain.py
@@ -23,7 +23,7 @@ from unittest.mock import patch
import pytest
from tests.gateway.restart_test_helpers import make_restart_runner
-from tools import browser_tool_lifecycle as bt_lifecycle
+from tools import browser_session_lifecycle as bt_lifecycle
@pytest.fixture(autouse=True)
diff --git a/tests/gateway/test_cron_interrupt_notification.py b/tests/gateway/test_cron_interrupt_notification.py
index 3debc5e5042..7dc005e9c3d 100644
--- a/tests/gateway/test_cron_interrupt_notification.py
+++ b/tests/gateway/test_cron_interrupt_notification.py
@@ -19,7 +19,7 @@ import pytest
from gateway.config import Platform
from tests.gateway.restart_test_helpers import make_restart_runner
-from tools import browser_tool_lifecycle as bt_lifecycle
+from tools import browser_session_lifecycle as bt_lifecycle
@pytest.fixture(autouse=True)
def _reset_cron_running_set():
diff --git a/tests/gateway/test_gateway_shutdown.py b/tests/gateway/test_gateway_shutdown.py
index 3ee4173a944..d3ccb86aaa2 100644
--- a/tests/gateway/test_gateway_shutdown.py
+++ b/tests/gateway/test_gateway_shutdown.py
@@ -10,7 +10,7 @@ from gateway.platforms.event import MessageEvent
from gateway.restart import DEFAULT_GATEWAY_POST_INTERRUPT_GRACE_TIMEOUT, GATEWAY_SERVICE_RESTART_EXIT_CODE
from gateway.session import build_session_key
from tests.gateway.restart_test_helpers import make_restart_runner, make_restart_source
-from tools import browser_tool_lifecycle as bt_lifecycle
+from tools import browser_session_lifecycle as bt_lifecycle
@pytest.mark.asyncio
diff --git a/tests/gateway/test_hygiene_deferred_work_drain.py b/tests/gateway/test_hygiene_deferred_work_drain.py
index 3f19cd122f1..77873b801c4 100644
--- a/tests/gateway/test_hygiene_deferred_work_drain.py
+++ b/tests/gateway/test_hygiene_deferred_work_drain.py
@@ -142,7 +142,7 @@ async def test_stop_interrupts_deferred_worker_before_teardown():
patch("cron.scheduler.mark_job_run"),
patch("tools.process_registry.process_registry.kill_all", return_value=0),
patch("tools.terminal_tool.cleanup_all_environments"),
- patch("tools.browser_tool_lifecycle.cleanup_all_browsers"),
+ patch("tools.browser_session_lifecycle.cleanup_all_browsers"),
):
await runner.stop()
diff --git a/tests/gateway/test_send_image_file.py b/tests/gateway/test_send_image_file.py
index 4482f8dab6c..6b82bc5e953 100644
--- a/tests/gateway/test_send_image_file.py
+++ b/tests/gateway/test_send_image_file.py
@@ -7,7 +7,6 @@ Covers: local image file sending, file-not-found handling, fallback on error,
"""
import asyncio
-import os
import sys
from unittest.mock import AsyncMock, MagicMock, patch
@@ -212,56 +211,3 @@ class TestSlackSendImageFile:
)
assert not result.success
assert "Not connected" in result.error
-
-
-# ---------------------------------------------------------------------------
-# browser_vision screenshot cleanup tests
-# ---------------------------------------------------------------------------
-
-
-class TestScreenshotCleanup:
- def test_cleanup_removes_old_screenshots(self, tmp_path):
- """_cleanup_old_screenshots should remove files older than max_age_hours."""
- import time
- from tools.browser_tool_lifecycle import _cleanup_old_screenshots
- from tools.browser_tool import _last_screenshot_cleanup_by_dir
-
- _last_screenshot_cleanup_by_dir.clear()
-
- # Create a "fresh" file
- fresh = tmp_path / "browser_screenshot_fresh.png"
- fresh.write_bytes(b"new")
-
- # Create an "old" file and backdate its mtime
- old = tmp_path / "browser_screenshot_old.png"
- old.write_bytes(b"old")
- old_time = time.time() - (25 * 3600) # 25 hours ago
- os.utime(str(old), (old_time, old_time))
-
- _cleanup_old_screenshots(tmp_path, max_age_hours=24)
-
- assert fresh.exists(), "Fresh screenshot should not be removed"
- assert not old.exists(), "Old screenshot should be removed"
-
- def test_cleanup_is_throttled_per_directory(self, tmp_path):
- import time
- from tools.browser_tool_lifecycle import _cleanup_old_screenshots
- from tools.browser_tool import _last_screenshot_cleanup_by_dir
-
- _last_screenshot_cleanup_by_dir.clear()
-
- old = tmp_path / "browser_screenshot_old.png"
- old.write_bytes(b"old")
- old_time = time.time() - (25 * 3600)
- os.utime(str(old), (old_time, old_time))
-
- _cleanup_old_screenshots(tmp_path, max_age_hours=24)
- assert not old.exists()
-
- old.write_bytes(b"old-again")
- os.utime(str(old), (old_time, old_time))
- _cleanup_old_screenshots(tmp_path, max_age_hours=24)
-
- assert old.exists(), "Repeated cleanup should be skipped while throttled"
-
-
diff --git a/tests/gateway/test_shutdown_kill_off_loop.py b/tests/gateway/test_shutdown_kill_off_loop.py
index 12950cdb654..9013fe15d98 100644
--- a/tests/gateway/test_shutdown_kill_off_loop.py
+++ b/tests/gateway/test_shutdown_kill_off_loop.py
@@ -43,7 +43,7 @@ def _make_phase_runner(monkeypatch, events):
lambda: events.append(("cleanup_envs", threading.current_thread())),
)
monkeypatch.setattr(
- "tools.browser_tool_lifecycle.cleanup_all_browsers",
+ "tools.browser_session_lifecycle.cleanup_all_browsers",
lambda: events.append(("cleanup_browsers", threading.current_thread())),
)
return runner, loop_thread
diff --git a/tests/hermes_cli/test_classic_browser_manage.py b/tests/hermes_cli/test_classic_browser_manage.py
index bd29ff123d6..90e0edb8928 100644
--- a/tests/hermes_cli/test_classic_browser_manage.py
+++ b/tests/hermes_cli/test_classic_browser_manage.py
@@ -105,9 +105,9 @@ def homes(tmp_path, monkeypatch):
monkeypatch.setenv("HERMES_HOME", str(launch))
monkeypatch.setattr(server, "_hermes_home", launch)
monkeypatch.delenv("BROWSER_CDP_URL", raising=False)
- import tools.browser_tool_lifecycle as lifecycle
- from tools import browser_tool_cdp
- monkeypatch.setattr(browser_tool_cdp, "_live_overrides", {})
+ import tools.browser_session_lifecycle as lifecycle
+ from tools import browser_session_cdp
+ monkeypatch.setattr(browser_session_cdp, "_live_overrides", {})
reaps = []
monkeypatch.setattr(lifecycle, "cleanup_profile_browsers", reaps.append)
monkeypatch.setattr(lifecycle, "cleanup_all_browsers", lambda: reaps.append("ALL"))
@@ -145,9 +145,9 @@ def _registry(launch, *homes):
def _resolved(home):
from gateway.run import _profile_runtime_scope
- from tools.browser_tool_cdp import _get_cdp_override_raw
+ from tools.browser_session_cdp import get_cdp_override_raw
with _profile_runtime_scope(home, hydrate_secrets=False):
- return _get_cdp_override_raw()
+ return get_cdp_override_raw()
def test_a_browser_one_profile_connects_never_reaches_another_profiles_session(homes, monkeypatch):
diff --git a/tests/hermes_cli/test_shared_metrics_loop.py b/tests/hermes_cli/test_shared_metrics_loop.py
index d30c2c9bd4c..e42aa399edf 100644
--- a/tests/hermes_cli/test_shared_metrics_loop.py
+++ b/tests/hermes_cli/test_shared_metrics_loop.py
@@ -308,13 +308,15 @@ def test_browser_calls_name_the_backend_that_served_them(home):
]
-def test_browser_tool_backend_is_resolved_from_the_profile_at_call_time(home, monkeypatch):
- import tools.browser_tool as bt
+def test_browser_backend_is_resolved_from_the_profile_at_call_time(home, monkeypatch):
+ from tools.browser_session_cloud import browser_backend_name
- handler = bt._routed_handler("browser_back", lambda args, kw: '{"success": true}')
- handler({}, task_id="t")
+ def handler():
+ return loop.record_browser_call(lambda legacy: legacy(lambda: '{"success": true}'), browser_backend_name)
+
+ handler()
monkeypatch.setenv("BROWSER_CDP_URL", "ws://127.0.0.1:9/devtools/browser/x") # `/browser connect` mid-session
- handler({}, task_id="t")
+ handler()
rows = sorted((d["backend"], d["outcome"]) for d, _ in _rows(home, "hermes.execution_backend.count"))
assert rows == [("cdp", "success"), ("local", "success")]
diff --git a/tests/tui_gateway/test_served_profile_child_env.py b/tests/tui_gateway/test_served_profile_child_env.py
index eae7bec936c..2a2be66b271 100644
--- a/tests/tui_gateway/test_served_profile_child_env.py
+++ b/tests/tui_gateway/test_served_profile_child_env.py
@@ -118,15 +118,15 @@ def test_helper_children_resolve_secrets_through_the_served_profile(mux_homes):
"""``key_cmd`` helpers and the browser driver spawned during B's turn see B's key, never A's."""
from agent.command_token_source import _mint
from gateway.run import _profile_runtime_scope
- from tools.browser_tool import _build_browser_env
+ from tools.browser_session import build_browser_env
_a, b = mux_homes
helper = (f"{sys.executable} -c \"import os;print(os.environ.get('B_MARKER','-')+'|'"
f"+os.environ.get('A_MARKER','-')+'|'+os.environ.get('HERMES_HOME',''))\"")
with _profile_runtime_scope(b, hydrate_secrets=False):
token, _ttl = _mint(helper, "b-provider")
- browser_env = _build_browser_env()
+ browser_env = build_browser_env()
assert token == f"b|-|{b}"
seen = _child_view(browser_env)
_assert_is_b_env(seen, b, with_secrets=False) # provider tier stays scrubbed for the browser
- assert seen["FIRECRAWL_API_KEY"] == "b-fc" # the passthrough key is B's, not the launch profile's
+ assert seen["FIRECRAWL_API_KEY"] is None # browser children get no provider keys, never the launch profile's
diff --git a/tests/tui_gateway/test_served_profile_child_env_authority.py b/tests/tui_gateway/test_served_profile_child_env_authority.py
index cfeefee041b..55e83201445 100644
--- a/tests/tui_gateway/test_served_profile_child_env_authority.py
+++ b/tests/tui_gateway/test_served_profile_child_env_authority.py
@@ -62,8 +62,8 @@ def test_ambient_only_launch_credential_never_reaches_a_routed_child(homes):
def test_routed_home_with_multiplex_flag_off_gets_no_launch_residue(homes, monkeypatch):
"""Desktop/dashboard topology: B served via the HERMES_HOME override only. The slash-worker /
- helper child sees B's env, and the browser passthrough resolves B's (absent) key as no key."""
- from tools.browser_tool import _build_browser_env
+ helper child sees B's env, and the browser child env carries no provider key for either profile."""
+ from tools.browser_session import build_browser_env
_a, b = homes
token = set_hermes_home_override(str(b))
@@ -71,12 +71,12 @@ def test_routed_home_with_multiplex_flag_off_gets_no_launch_residue(homes, monke
env = served_profile_child_env(inherit_credentials=True)
assert env["HERMES_HOME"] == str(b) and env["B_MARKER"] == "b"
assert "A_MARKER" not in env and "HERMES_MODEL" not in env and "OPENAI_API_KEY" not in env
- browser_env = _build_browser_env()
+ browser_env = build_browser_env()
assert "FIRECRAWL_API_KEY" not in browser_env and browser_env["HERMES_HOME"] == str(b)
finally:
reset_hermes_home_override(token)
- # Control: the launch profile's own browser keeps its key and its settings.
- assert _build_browser_env()["FIRECRAWL_API_KEY"] == "a-fc"
+ # Control: the launch profile's browser env is credential-free too; its other children keep their settings.
+ assert "FIRECRAWL_API_KEY" not in build_browser_env()
assert served_profile_child_env(inherit_credentials=True)["HERMES_MODEL"] == "a-model"
diff --git a/tests/tui_gateway/test_tui_gateway_server_browser_manage.py b/tests/tui_gateway/test_tui_gateway_server_browser_manage.py
index cd29d6e5af4..01fa2177427 100644
--- a/tests/tui_gateway/test_tui_gateway_server_browser_manage.py
+++ b/tests/tui_gateway/test_tui_gateway_server_browser_manage.py
@@ -1,7 +1,7 @@
"""``browser.manage`` RPCs: connect/disconnect/status (split from ``test_tui_gateway_server.py``).
Since CLI-9 (#134889) the live ``/browser connect`` endpoint is the requesting profile's (a per-home
-map in ``tools.browser_tool_cdp``), and only that profile's browsers are reaped.
+map in ``tools.browser_session_cdp``), and only that profile's browsers are reaped.
"""
import json
import os
@@ -102,13 +102,13 @@ def test_browser_manage_has_no_use_action_and_status_reports_no_mode():
@pytest.fixture(autouse=True)
def _no_live_cdp(monkeypatch):
"""Each test starts with no profile's live ``/browser connect`` endpoint."""
- from tools import browser_tool_cdp
- monkeypatch.setattr(browser_tool_cdp, "_live_overrides", {})
+ from tools import browser_session_cdp
+ monkeypatch.setattr(browser_session_cdp, "_live_overrides", {})
def _live_cdp() -> str:
"""The launch profile's live ``/browser connect`` endpoint (per profile since CLI-9)."""
- from tools.browser_tool_cdp import live_cdp_override
+ from tools.browser_session_cdp import live_cdp_override
return live_cdp_override()
@@ -127,7 +127,7 @@ def test_browser_manage_connect_sets_env_and_cleans_twice(monkeypatch):
cleanup_profile_browsers=_cleanup_all,
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
_stub_urlopen(monkeypatch, ok=True)
resp = server.handle_request(
{
@@ -150,7 +150,7 @@ def test_browser_manage_connect_defaults_to_loopback(monkeypatch):
cleanup_profile_browsers=lambda _key: None,
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
urls = _stub_urlopen_capture(monkeypatch, ok=True)
resp = server.handle_request(
{"id": "1", "method": "browser.manage", "params": {"action": "connect"}}
@@ -177,7 +177,7 @@ def test_browser_manage_connect_default_local_reports_launch_hint(monkeypatch):
cleanup_profile_browsers=lambda _key: None,
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
_stub_urlopen(monkeypatch, ok=False)
with (
patch(
@@ -226,7 +226,7 @@ def test_browser_manage_connect_no_session_skips_progress_events(monkeypatch):
cleanup_profile_browsers=lambda _key: None,
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
_stub_urlopen(monkeypatch, ok=False)
with (
patch(
@@ -261,7 +261,7 @@ def test_browser_manage_connect_handles_null_url(monkeypatch):
cleanup_profile_browsers=lambda _key: None,
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
_stub_urlopen(monkeypatch, ok=True)
resp = server.handle_request(
{
@@ -322,7 +322,7 @@ def test_browser_manage_connect_default_local_retries_after_launch(monkeypatch):
monkeypatch.setattr(urllib.request.OpenerDirector, "open", lambda _self, url, *a, timeout=2.0, **k: _opener(url, timeout=timeout))
launched = ChromeDebugLaunch(launched=True)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
with (
patch(
"hermes_cli.browser_connect.launch_chrome_debug",
@@ -366,7 +366,7 @@ def test_browser_manage_connect_finds_ipv6_only_browser(monkeypatch):
import urllib.request
monkeypatch.setattr(urllib.request.OpenerDirector, "open", lambda _self, url, *a, timeout=2.0, **k: _opener(url, timeout=timeout))
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
resp = server.handle_request(
{"id": "1", "method": "browser.manage", "params": {"action": "connect"}}
)
@@ -410,7 +410,7 @@ def test_browser_manage_connect_squatted_port_launches_on_alternate(monkeypatch)
launch_ports.append(port)
return ChromeDebugLaunch(launched=True)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
with (
patch("hermes_cli.browser_connect.launch_chrome_debug", side_effect=_launch),
patch("hermes_cli.browser_connect.local_port_in_use", return_value=True),
@@ -428,7 +428,7 @@ def test_browser_manage_connect_squatted_port_launches_on_alternate(monkeypatch)
def test_browser_manage_connect_rejects_unreachable_endpoint(monkeypatch):
"""An unreachable endpoint must NOT mutate the env or reap sessions."""
- from tools.browser_tool_cdp import set_live_cdp_override
+ from tools.browser_session_cdp import set_live_cdp_override
set_live_cdp_override("http://existing:9222")
cleanup_calls: list[str] = []
fake = types.SimpleNamespace(
@@ -437,7 +437,7 @@ def test_browser_manage_connect_rejects_unreachable_endpoint(monkeypatch):
),
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
_stub_urlopen(monkeypatch, ok=False)
resp = server.handle_request(
{
@@ -462,7 +462,7 @@ def test_browser_manage_connect_normalizes_bare_host_port(monkeypatch):
cleanup_profile_browsers=lambda _key: None,
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
_stub_urlopen(monkeypatch, ok=True)
resp = server.handle_request(
{
@@ -488,7 +488,7 @@ def test_browser_manage_connect_strips_discovery_path(monkeypatch):
cleanup_profile_browsers=lambda _key: None,
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
_stub_urlopen(monkeypatch, ok=True)
resp = server.handle_request(
{
@@ -520,7 +520,7 @@ def test_browser_manage_connect_preserves_devtools_browser_endpoint(monkeypatch)
def __exit__(self, *a):
return False
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
# If urlopen is reached for a concrete ws endpoint, the test
# would still pass because _stub_urlopen returned ok=True before;
# patch it to assert-fail so we prove the HTTP probe is skipped.
@@ -559,7 +559,7 @@ def test_browser_manage_connect_local_devtools_ws_preserves_path(monkeypatch):
def __exit__(self, *a):
return False
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
with patch("socket.create_connection", return_value=_OkSocket()):
resp = server.handle_request(
{
@@ -626,7 +626,7 @@ def test_browser_manage_connect_concrete_ws_skips_http_probe(monkeypatch):
seen_targets.append(addr)
return _OkSocket()
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
# urlopen would 404/ECONNREFUSED on a real hosted CDP endpoint;
# asserting it's never called proves the probe was skipped.
with patch(
@@ -657,7 +657,7 @@ def test_browser_manage_connect_concrete_ws_tcp_unreachable(monkeypatch):
)
concrete = "ws://offline.example/devtools/browser/missing"
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
with patch("socket.create_connection", side_effect=OSError("ECONNREFUSED")):
resp = server.handle_request(
{
@@ -672,7 +672,7 @@ def test_browser_manage_connect_concrete_ws_tcp_unreachable(monkeypatch):
def test_browser_manage_disconnect_drops_env_and_cleans(monkeypatch):
- from tools.browser_tool_cdp import set_live_cdp_override
+ from tools.browser_session_cdp import set_live_cdp_override
monkeypatch.setenv("BROWSER_CDP_URL", "http://operator:9222") # an operator's env is not the live connect
set_live_cdp_override("http://127.0.0.1:9222")
cleanup_count = {"n": 0}
@@ -682,7 +682,7 @@ def test_browser_manage_disconnect_drops_env_and_cleans(monkeypatch):
),
_get_cdp_override=lambda: os.environ.get("BROWSER_CDP_URL", ""),
)
- with patch.dict(sys.modules, {"tools.browser_tool_lifecycle": fake}):
+ with patch.dict(sys.modules, {"tools.browser_session_lifecycle": fake}):
resp = server.handle_request(
{"id": "1", "method": "browser.manage", "params": {"action": "disconnect"}}
)
diff --git a/tui_gateway/methods_browser.py b/tui_gateway/methods_browser.py
index 775bf330050..137d2377ef9 100644
--- a/tui_gateway/methods_browser.py
+++ b/tui_gateway/methods_browser.py
@@ -12,10 +12,10 @@ _CDP_SCHEMES = {"http", "https", "ws", "wss"}
def _resolve_browser_cdp_url() -> str:
"""Configured browser CDP override without network I/O (``/browser status`` must be fast;
- ``tools.browser_tool_cdp._get_cdp_override`` HTTP-probes discovery URLs). Same precedence (this
- profile's live connect, env, then ``browser.cdp_url``) minus WS resolution; ``browser_navigate``
- normalizes on the next call."""
- from tools.browser_tool_cdp import env_cdp_url, live_cdp_override
+ ``tools.browser_session_cdp.get_cdp_override`` HTTP-probes discovery URLs). Same precedence (this
+ profile's live connect, env, then ``browser.cdp_url``) minus WS resolution; the next browser
+ session normalizes it."""
+ from tools.browser_session_cdp import env_cdp_url, live_cdp_override
if env_url := live_cdp_override() or env_cdp_url():
return env_url
with contextlib.suppress(Exception):
@@ -99,14 +99,14 @@ def _reap_profile_browsers() -> None:
"""Close the current profile's browsers only: the live connection is per profile, so other
profiles' sessions on a multiplexed gateway keep theirs."""
from hermes_constants import hermes_home_key
- from tools.browser_tool_lifecycle import cleanup_profile_browsers
+ from tools.browser_session_lifecycle import cleanup_profile_browsers
cleanup_profile_browsers(hermes_home_key())
def _browser_connect(rid, params: dict) -> dict:
import platform
from hermes_cli.browser_connect import DEFAULT_BROWSER_CDP_URL
- from tools.browser_tool_cdp import set_live_cdp_override
+ from tools.browser_session_cdp import set_live_cdp_override
from urllib.parse import urlparse
raw_url = params.get("url")
if raw_url is not None and not isinstance(raw_url, str):
@@ -135,7 +135,7 @@ def _browser_connect(rid, params: dict) -> dict:
port = parsed.port or 9222
try:
# Hosted ws[s]://.../devtools/browser/<id> endpoints don't serve the HTTP discovery path:
- # check TCP reachability only and let browser_navigate handshake.
+ # check TCP reachability only and let the browser session handshake.
if parsed.scheme in {"ws", "wss"} and parsed.path.startswith("/devtools/browser/"):
import socket
try:
@@ -169,7 +169,7 @@ def _browser_connect(rid, params: dict) -> dict:
def _browser_disconnect(rid) -> dict:
# Reap, drop this profile's override, reap again — same swap window as ``_browser_connect``.
- from tools.browser_tool_cdp import set_live_cdp_override
+ from tools.browser_session_cdp import set_live_cdp_override
def reap() -> None:
with contextlib.suppress(Exception):