Skip to content

Automate browser based workflows with AI

Probe inherited-browser transport liveness before reusing a page-less browser (#7997)

LawyZheng6467bc19f804
diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.py
index 425acd6f0..4fad9462f 100644
--- a/skyvern/webeye/real_browser_manager.py
+++ b/skyvern/webeye/real_browser_manager.py
@@ -54,6 +54,69 @@ def _is_cached_cdp_drop_error(exc: FailedToNavigateToUrl) -> bool:
return any(needle in message for needle in _CACHED_CDP_DROP_ERROR_SUBSTRINGS)
+# A bounded, read-only probe confirms an inherited browser's transport is really alive before
+# the same-context (#14311) recovery runs new_page() on it. Kept small so the rare page-less
+# inheritance path never stalls; a live cookies() round-trip returns well under this.
+_INHERITED_BROWSER_LIVENESS_PROBE_TIMEOUT_SECONDS = 5.0
+
+# Closed-transport signatures matched by message substring and by type NAME, never by imported
+# class identity: scripts/patch_browser.sh rewrites playwright -> patchright for the agent image
+# but not for cloud/persistent_browsers, so the two packages expose distinct TargetClosedError
+# classes (see skyvern/webeye/cdp_frame_publisher.py for the same name-based matching).
+_CLOSED_TRANSPORT_ERROR_SUBSTRINGS = (
+ "Connection closed while reading from the driver",
+ "Target page, context or browser has been closed",
+ "Target closed",
+ "Browser closed",
+)
+_CLOSED_TRANSPORT_ERROR_TYPE_NAMES = ("TargetClosedError",)
+
+
+def _is_closed_transport_error(exc: BaseException) -> bool:
+ if type(exc).__name__ in _CLOSED_TRANSPORT_ERROR_TYPE_NAMES:
+ return True
+ message = str(exc)
+ return any(needle in message for needle in _CLOSED_TRANSPORT_ERROR_SUBSTRINGS)
+
+
+async def _inherited_browser_transport_alive(browser_state: BrowserState) -> bool:
+ """Truthfully classify an inherited, page-less browser as connected before same-context recovery.
+
+ ``is_connected()`` only inspects cached client-side flags, so a driver/CDP transport that died
+ with no I/O since (a long sequential-gate wait, a reaped remote browser, a NAT/LB idle timeout,
+ a TCP half-close) still reports connected. Confirm with one bounded, read-only round-trip:
+ a genuinely live tab-less context answers and is reused (preserving cookies/session), while a
+ dead transport is classified disconnected here and routed to the existing fresh-browser path,
+ instead of crashing the #14311 ``new_page()`` recovery with
+ "Connection closed while reading from the driver" (SKY-13389).
+ """
+ if not browser_state.is_connected():
+ return False
+ context = browser_state.browser_context
+ if context is None:
+ return False
+ try:
+ async with asyncio.timeout(_INHERITED_BROWSER_LIVENESS_PROBE_TIMEOUT_SECONDS):
+ await context.cookies()
+ except (asyncio.CancelledError, KeyboardInterrupt, SystemExit):
+ # Process-control signals are never a browser-liveness verdict — propagate untouched.
+ raise
+ except (asyncio.TimeoutError, TimeoutError):
+ LOG.info("Inherited browser liveness probe timed out; treating browser as disconnected")
+ return False
+ except Exception as exc:
+ # Only a genuinely closed transport counts as disconnected; anything else is an unexpected
+ # programming error that must not be silently swallowed into a fresh-browser fallback.
+ if _is_closed_transport_error(exc):
+ LOG.info(
+ "Inherited browser liveness probe hit a closed transport; treating browser as disconnected",
+ error=str(exc),
+ )
+ return False
+ raise
+ return True
+
+
async def _rebind_pbs_download_dir(
browser_state: BrowserState,
workflow_run: WorkflowRun,
@@ -573,11 +636,13 @@ class RealBrowserManager(BrowserManager):
# browser here. This early-return path skips get_or_create_page, so returning a
# page-less state would fail the run's first browser block with a missing page.
working_page = await browser_state.get_working_page()
- if working_page is None and browser_state.is_connected():
+ if working_page is None and await _inherited_browser_transport_alive(browser_state):
# The inherited browser is still live but its last valid tab was closed
# (e.g. a use_parent_browser_session child whose prior run closed the last
# page). Recreate a page in the SAME context so the child keeps the parent's
# cookies/session, instead of orphaning the live browser and starting fresh.
+ # Liveness is actively probed (not just is_connected()'s cached flags) so a
+ # transport that died while idle falls through to a fresh browser (SKY-13389).
LOG.info(
"Inherited parent browser is live but has no working page; recreating a page in the same context",
workflow_run_id=workflow_run_id,
diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.py
index 1e6d5f59d..9c2e9262c 100644
--- a/tests/unit/test_real_browser_manager.py
+++ b/tests/unit/test_real_browser_manager.py
@@ -6,6 +6,7 @@ behind `if not browser_session_id:`, causing PBS workflow runs to skip the cache
on every call and re-invoke navigate_to_url() on every step.
"""
+import asyncio
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
@@ -233,6 +234,9 @@ async def test_child_run_recovers_live_inherited_browser_without_page() -> None:
live_state = MagicMock()
live_state.get_working_page = AsyncMock(side_effect=[None, MagicMock()])
live_state.is_connected = MagicMock(return_value=True)
+ # A genuinely live tab-less context answers the bounded read-only liveness probe.
+ live_state.browser_context = MagicMock()
+ live_state.browser_context.cookies = AsyncMock(return_value=[])
live_state.get_or_create_page = AsyncMock()
manager.pages["wfr_parent"] = live_state
@@ -255,6 +259,189 @@ async def test_child_run_recovers_live_inherited_browser_without_page() -> None:
assert manager.pages["wfr_parent"] is live_state
+class _FakeDriverClosedError(Exception):
+ """Production-shaped closed-transport error: a dead Playwright/Patchright driver pipe
+ surfaces this message on the first round-trip after the connection silently died."""
+
+
+class TargetClosedError(Exception):
+ """Named to match Playwright/Patchright ``TargetClosedError`` by type name only.
+
+ ``scripts/patch_browser.sh`` rewrites playwright -> patchright for the agent image but not
+ for ``cloud/persistent_browsers``, so closed-transport classification must match by type
+ name/message, never by imported class identity.
+ """
+
+
+async def test_child_run_does_not_adopt_inherited_browser_with_dead_transport() -> None:
+ """SKY-13389: ``is_connected()`` only reads cached client-side flags, so an inherited browser
+ whose driver/CDP transport died while idle (a long sequential-gate wait, a reaped remote
+ browser, a TCP half-close) still reports connected. Taking the #14311 same-context recovery
+ then runs ``new_page()`` on a dead transport and crashes the run with
+ "Connection closed while reading from the driver". The manager must actively probe the
+ transport before same-context recovery and, on a dead transport, evict + create a fresh
+ browser instead.
+ """
+ manager = RealBrowserManager()
+ # Inherited parent-key browser: page-less, reports connected (cached false positive),
+ # but every real round-trip over its dead driver raises the closed-transport error.
+ dead_state = MagicMock()
+ dead_state.get_working_page = AsyncMock(return_value=None)
+ dead_state.is_connected = MagicMock(return_value=True)
+ dead_state.browser_context = MagicMock()
+ dead_state.browser_context.cookies = AsyncMock(
+ side_effect=_FakeDriverClosedError("BrowserContext.cookies: Connection closed while reading from the driver")
+ )
+ # If the pre-fix #14311 path is taken, new_page() inside get_or_create_page raises the same
+ # error and crashes the run (reproducing the production crash signature).
+ dead_state.get_or_create_page = AsyncMock(
+ side_effect=_FakeDriverClosedError("BrowserContext.new_page: Connection closed while reading from the driver")
+ )
+ manager.pages["wfr_parent"] = dead_state
+
+ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")
+ fresh_state = MagicMock()
+ fresh_state.get_or_create_page = AsyncMock()
+
+ with patch.object(manager, "_create_browser_state", new=AsyncMock(return_value=fresh_state)) as mock_create:
+ result = await manager.get_or_create_for_workflow_run(
+ workflow_run=workflow_run,
+ url="https://example.com",
+ browser_session_id=None,
+ )
+
+ # A fresh browser is created; the dead browser is never recovered in-place.
+ mock_create.assert_awaited_once()
+ assert result is fresh_state
+ assert result is not dead_state
+ dead_state.get_or_create_page.assert_not_awaited()
+ assert manager.pages["wfr_child"] is fresh_state
+ assert manager.pages["wfr_parent"] is fresh_state
+
+
+async def test_child_run_evicts_inherited_browser_when_transport_probe_times_out() -> None:
+ """A dead transport can hang rather than error; the bounded probe must time out and classify
+ the inherited browser disconnected so the run gets a fresh browser instead of stalling."""
+ manager = RealBrowserManager()
+ dead_state = MagicMock()
+ dead_state.get_working_page = AsyncMock(return_value=None)
+ dead_state.is_connected = MagicMock(return_value=True)
+
+ async def _hang(*args: object, **kwargs: object) -> list:
+ await asyncio.sleep(1)
+ return []
+
+ dead_state.browser_context = MagicMock()
+ dead_state.browser_context.cookies = _hang
+ dead_state.get_or_create_page = AsyncMock()
+ manager.pages["wfr_parent"] = dead_state
+
+ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")
+ fresh_state = MagicMock()
+ fresh_state.get_or_create_page = AsyncMock()
+
+ with (
+ patch.object(real_browser_manager, "_INHERITED_BROWSER_LIVENESS_PROBE_TIMEOUT_SECONDS", 0.01),
+ patch.object(manager, "_create_browser_state", new=AsyncMock(return_value=fresh_state)) as mock_create,
+ ):
+ result = await manager.get_or_create_for_workflow_run(
+ workflow_run=workflow_run,
+ url="https://example.com",
+ browser_session_id=None,
+ )
+
+ mock_create.assert_awaited_once()
+ assert result is fresh_state
+ dead_state.get_or_create_page.assert_not_awaited()
+
+
+async def test_child_run_evicts_inherited_browser_on_target_closed_by_name() -> None:
+ """Closed-transport is classified by exception type NAME, not imported identity, because
+ scripts/patch_browser.sh swaps playwright -> patchright for the agent image only. A
+ TargetClosedError from either package (message alone not matching) still evicts + goes fresh."""
+ manager = RealBrowserManager()
+ dead_state = MagicMock()
+ dead_state.get_working_page = AsyncMock(return_value=None)
+ dead_state.is_connected = MagicMock(return_value=True)
+ dead_state.browser_context = MagicMock()
+ dead_state.browser_context.cookies = AsyncMock(side_effect=TargetClosedError("boom"))
+ dead_state.get_or_create_page = AsyncMock()
+ manager.pages["wfr_parent"] = dead_state
+
+ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")
+ fresh_state = MagicMock()
+ fresh_state.get_or_create_page = AsyncMock()
+
+ with patch.object(manager, "_create_browser_state", new=AsyncMock(return_value=fresh_state)) as mock_create:
+ result = await manager.get_or_create_for_workflow_run(
+ workflow_run=workflow_run,
+ url="https://example.com",
+ browser_session_id=None,
+ )
+
+ mock_create.assert_awaited_once()
+ assert result is fresh_state
+ dead_state.get_or_create_page.assert_not_awaited()
+
+
+async def test_child_run_reraises_unexpected_probe_error() -> None:
+ """An unexpected (non closed-transport) probe error must propagate, never be silently
+ converted into a fresh-browser fallback that could mask a real defect."""
+ manager = RealBrowserManager()
+ state = MagicMock()
+ state.get_working_page = AsyncMock(return_value=None)
+ state.is_connected = MagicMock(return_value=True)
+ state.browser_context = MagicMock()
+ state.browser_context.cookies = AsyncMock(side_effect=ValueError("unexpected probe failure"))
+ manager.pages["wfr_parent"] = state
+
+ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")
+
+ with patch.object(manager, "_create_browser_state", new=AsyncMock()) as mock_create:
+ with pytest.raises(ValueError, match="unexpected probe failure"):
+ await manager.get_or_create_for_workflow_run(
+ workflow_run=workflow_run,
+ url="https://example.com",
+ browser_session_id=None,
+ )
+
+ mock_create.assert_not_awaited()
+
+
+async def test_inherited_browser_transport_alive_skips_probe_when_already_disconnected() -> None:
+ state = MagicMock()
+ state.is_connected = MagicMock(return_value=False)
+ state.browser_context = MagicMock()
+ state.browser_context.cookies = AsyncMock()
+
+ assert await real_browser_manager._inherited_browser_transport_alive(state) is False
+ state.browser_context.cookies.assert_not_awaited()
+
+
+async def test_inherited_browser_transport_alive_false_when_no_context() -> None:
+ state = MagicMock()
+ state.is_connected = MagicMock(return_value=True)
+ state.browser_context = None
+
+ assert await real_browser_manager._inherited_browser_transport_alive(state) is False
+
+
+async def test_inherited_browser_transport_alive_true_when_probe_succeeds() -> None:
+ state = MagicMock()
+ state.is_connected = MagicMock(return_value=True)
+ state.browser_context = MagicMock()
+ state.browser_context.cookies = AsyncMock(return_value=[])
+
+ assert await real_browser_manager._inherited_browser_transport_alive(state) is True
+
+
def make_task(
task_id: str,
organization_id: str = "org_test",
diff --git a/tests/unit/workflow/test_block_browser_state_recovery.py b/tests/unit/workflow/test_block_browser_state_recovery.py
index a4302aa9a..1d0d29e57 100644
--- a/tests/unit/workflow/test_block_browser_state_recovery.py
+++ b/tests/unit/workflow/test_block_browser_state_recovery.py
@@ -226,6 +226,18 @@ def test_is_connected_false_when_driver_connection_closed() -> None:
assert _state_with_context(context).is_connected() is False
+def test_is_connected_true_when_context_browser_is_none() -> None:
+ # A CDP-connected context can expose ``browser is None``; is_connected() then reports True from
+ # cached impl flags alone, with no transport round-trip. This passive True is exactly why the
+ # page-less inheritance seam actively probes the transport before same-context recovery
+ # (RealBrowserManager._inherited_browser_transport_alive) rather than trusting is_connected()
+ # (SKY-13389).
+ context = MagicMock()
+ context.browser = None
+ context._impl_obj = MagicMock(_close_was_called=False, _closed=False, _connection=MagicMock(_closed_error=None))
+ assert _state_with_context(context).is_connected() is True
+
+
def _free_port() -> int:
with socket.socket() as sock:
sock.bind(("127.0.0.1", 0))