Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix: reap browser sessions whose runnable owner type cannot be resolved (#8027)
Aaron Perez2ce677109fc8
diff --git a/skyvern/webeye/browser_manager.py b/skyvern/webeye/browser_manager.pyindex 140f770be..cea59d89e 100644--- a/skyvern/webeye/browser_manager.py+++ b/skyvern/webeye/browser_manager.py@@ -60,6 +60,11 @@ class BrowserManager(Protocol):organization_id: str | None = None,) -> BrowserState: ...+ def live_session_runnable_ids(self) -> set[str]:+ """Runnables holding a persistent session in this process — leased, or mid-acquisition — i.e.+ still running here. An implementation that tracks none reports none and is never protected."""+ return set()+async def cleanup_for_script(self,script_id: str,diff --git a/skyvern/webeye/default_persistent_sessions_manager.py b/skyvern/webeye/default_persistent_sessions_manager.pyindex 8cca469bb..f67f8f112 100644--- a/skyvern/webeye/default_persistent_sessions_manager.py+++ b/skyvern/webeye/default_persistent_sessions_manager.py@@ -752,11 +752,18 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):A run that dies before release_browser_session leaves runnable_id set forever; treating aterminal or missing owner as inactive lets the normal timeout+grace gate reclaim the session- instead of skipping it forever. Owners we can't authoritatively resolve — an unrecognized- runnable type or a lookup failure — are treated as active, so a reap never races a run we- can't prove is gone."""+ instead of skipping it forever. A resolvable owner whose lookup fails is treated as active,+ so a reap never races a run we could have proven live but couldn't reach.++ A runnable type we have no lookup for can't be resolved either way, so the only liveness+ signal left is process-local: a runnable holding a session here — mid-acquisition or leased —+ is still running (nothing renews a standalone script's session, so its run can outlive the+ timeout). Once that ends at the run's terminal boundary the session falls through to the+ caller's own gate — timeout+grace in the reaper, a terminal row in reconcile — rather than+ staying protected forever. A new runnable type that occupies a session must therefore either+ be resolvable here or report itself live there, or its runs are reaped mid-flight."""if runnable_type not in (RunType.workflow_run, PBS_TASK_RUNNABLE_TYPE):- return True+ return runnable_id in app.BROWSER_MANAGER.live_session_runnable_ids()try:if runnable_type == PBS_TASK_RUNNABLE_TYPE:owner = await self.database.tasks.get_task(runnable_id, organization_id=organization_id)@@ -862,7 +869,7 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):# cleanup — never yank a browser out from under a live task/workflow. But close only sets# completed_at/status without clearing runnable_id, and a completed row is invisible to# reap_expired_sessions, so resolve the owner the same way the reaper does and skip only a- # still-live/unknown owner; a terminal/missing owner falls through to reclaim below.+ # still-live owner; a terminal/missing/unresolvable owner falls through to reclaim below.if (db_session is not Noneand db_session.runnable_id is not Nonediff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex 4b02c9204..b02361561 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -239,6 +239,10 @@ class RealBrowserManager(BrowserManager):# The runnable identity accepted by begin_session, carried unchanged into teardown. Cleanup# reads this lease instead of reconstructing identity from Task/Workflow fields.self._persistent_session_leases: dict[str, _PersistentSessionLease] = {}+ # Runnables between begin_session and their lease. Occupancy is published first and occupy+ # does not extend the session's timeout, so without this a reused-but-expired session is+ # unprotected for the whole attach.+ self._acquiring_session_runnables: set[str] = set()# CDP frame publishers keyed by stream key (``{wr}.png`` / ``{task}.png``).self._frame_publishers: dict[str, CDPFramePublisher] = {}# Serializes the check/create/start/store/register sequence in@@ -286,6 +290,9 @@ class RealBrowserManager(BrowserManager):if lease is not None and self._persistent_session_leases.get(run_id) is lease:self._persistent_session_leases.pop(run_id, None)+ def live_session_runnable_ids(self) -> set[str]:+ return set(self._persistent_session_leases) | self._acquiring_session_runnables+async def _start_frame_publisher(self,*,@@ -1364,46 +1371,52 @@ class RealBrowserManager(BrowserManager):raise MissingOrganizationForBrowserSession(browser_session_id)if not script_id:raise MissingBrowserStateForBrowserSession(browser_session_id)- raw_generation_id = await app.PERSISTENT_SESSIONS_MANAGER.begin_session(- browser_session_id=browser_session_id,- runnable_type="script",- runnable_id=script_id,- organization_id=organization_id,- )- expected_runnable_generation_id = raw_generation_id if isinstance(raw_generation_id, str) else None- if context is not None:- context.browser_session_runnable_id = script_id- context.browser_session_runnable_generation_id = expected_runnable_generation_id- download_run_id = resolve_run_download_id(skyvern_context.current(), fallback_run_id=script_id) or script_id- LOG.info(- "Getting browser state for script",- browser_session_id=browser_session_id,- )- browser_state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(- browser_session_id,- **{- "organization_id": organization_id,- "expected_runnable_id": script_id,- "download_run_id": download_run_id,- **(- {"expected_runnable_generation_id": expected_runnable_generation_id}- if expected_runnable_generation_id is not None- else {}- ),- },- )- if browser_state is None:- # Fail closed: a cold/evicted session has no reusable state. Silently creating a local- # browser below would produce an unregistered state that terminal cleanup misclassifies as- # a reusable persistent session (keyed off browser_session_id) and leaks instead of closes.- raise MissingBrowserStateForBrowserSession(browser_session_id)- self._persistent_session_leases[script_id] = _PersistentSessionLease(- session_id=browser_session_id,- organization_id=organization_id,- runnable_id=script_id,- runnable_generation_id=expected_runnable_generation_id,- browser_state=browser_state,- )+ self._acquiring_session_runnables.add(script_id)+ try:+ raw_generation_id = await app.PERSISTENT_SESSIONS_MANAGER.begin_session(+ browser_session_id=browser_session_id,+ runnable_type="script",+ runnable_id=script_id,+ organization_id=organization_id,+ )+ expected_runnable_generation_id = raw_generation_id if isinstance(raw_generation_id, str) else None+ if context is not None:+ context.browser_session_runnable_id = script_id+ context.browser_session_runnable_generation_id = expected_runnable_generation_id+ download_run_id = (+ resolve_run_download_id(skyvern_context.current(), fallback_run_id=script_id) or script_id+ )+ LOG.info(+ "Getting browser state for script",+ browser_session_id=browser_session_id,+ )+ browser_state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(+ browser_session_id,+ **{+ "organization_id": organization_id,+ "expected_runnable_id": script_id,+ "download_run_id": download_run_id,+ **(+ {"expected_runnable_generation_id": expected_runnable_generation_id}+ if expected_runnable_generation_id is not None+ else {}+ ),+ },+ )+ if browser_state is None:+ # Fail closed: a cold/evicted session has no reusable state. Silently creating a local+ # browser below would produce an unregistered state that terminal cleanup misclassifies as+ # a reusable persistent session (keyed off browser_session_id) and leaks instead of closes.+ raise MissingBrowserStateForBrowserSession(browser_session_id)+ self._persistent_session_leases[script_id] = _PersistentSessionLease(+ session_id=browser_session_id,+ organization_id=organization_id,+ runnable_id=script_id,+ runnable_generation_id=expected_runnable_generation_id,+ browser_state=browser_state,+ )+ finally:+ self._acquiring_session_runnables.discard(script_id)page = await browser_state.get_working_page()if not page:LOG.warning("Browser state has no page to run the script", script_id=script_id)@@ -1478,13 +1491,11 @@ class RealBrowserManager(BrowserManager):# Best-effort per the "errors are logged, not raised" contract: a release failure must not# escape cleanup and mask the script's own exception (this runs in run_script's finally).try:- released = await self._release_persistent_session(+ await self._release_persistent_session(browser_session_id,organization_id,session_lease,)- if released:- self._discard_session_lease(script_id, session_lease)LOG.info("Released browser session", browser_session_id=browser_session_id)except Exception:LOG.warning(@@ -1493,6 +1504,11 @@ class RealBrowserManager(BrowserManager):browser_session_id=browser_session_id,exc_info=True,)+ finally:+ # This is the script's only cleanup call, so a retained lease is never retried —+ # it just reads as "still running" to the reaper's lease gate and pins the+ # session. Drop it either way and leave the occupied row to the reaper.+ self._discard_session_lease(script_id, session_lease)elif browser_session_id:LOG.warning("Organization ID not specified, cannot release browser session", script_id=script_id)return browser_state_to_closediff --git a/tests/unit/test_persistent_session_reaper.py b/tests/unit/test_persistent_session_reaper.pyindex 2229f4995..2088d80e2 100644--- a/tests/unit/test_persistent_session_reaper.py+++ b/tests/unit/test_persistent_session_reaper.py@@ -2,6 +2,7 @@Chromium + record_video ffmpeg encoders don't leak."""import asyncio+from collections.abc import Iteratorfrom datetime import datetime, timedelta, timezonefrom types import SimpleNamespacefrom unittest.mock import AsyncMock, MagicMock, patch@@ -12,10 +13,30 @@ from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatusfrom skyvern.schemas.run_enums import RunTypefrom skyvern.webeye import default_persistent_sessions_manager as manager_modfrom skyvern.webeye.default_persistent_sessions_manager import BrowserSession, DefaultPersistentSessionsManager+from skyvern.webeye.real_browser_manager import RealBrowserManager, _PersistentSessionLeaseMODULE = "skyvern.webeye.default_persistent_sessions_manager"[email protected](autouse=True)+def browser_manager() -> Iterator[RealBrowserManager]:+ """The reaper reads in-process session leases off app.BROWSER_MANAGER, and the real app proxy+ raises unless a ForgeApp was started. Yielding the manager lets a test register a live lease."""+ manager = RealBrowserManager()+ with patch.object(manager_mod, "app", SimpleNamespace(BROWSER_MANAGER=manager)):+ yield manager+++def _lease(browser_manager: RealBrowserManager, runnable_id: str, session_id: str) -> None:+ """Register the lease production writes when a runnable acquires a persistent session."""+ browser_manager._persistent_session_leases[runnable_id] = _PersistentSessionLease(+ session_id=session_id,+ organization_id="org_test",+ runnable_id=runnable_id,+ browser_state=MagicMock(),+ )++def _make_manager(uncompleted_sessions: list, owned_ids: list[str] | None = None) -> DefaultPersistentSessionsManager:DefaultPersistentSessionsManager.instance = NoneDefaultPersistentSessionsManager._browser_sessions = {}@@ -25,8 +46,11 @@ def _make_manager(uncompleted_sessions: list, owned_ids: list[str] | None = Nonedb.browser_sessions = MagicMock()db.browser_sessions.get_uncompleted_persistent_browser_sessions = AsyncMock(return_value=uncompleted_sessions)db.workflow_runs = MagicMock()+ db.tasks = MagicMock()# Default: the owning run row is gone (stale). Tests that need a live/terminal owner override this.+ # Both owner lookups are real AsyncMocks so an assert_not_awaited() on them can actually fail.db.workflow_runs.get_workflow_run = AsyncMock(return_value=None)+ db.tasks.get_task = AsyncMock(return_value=None)manager = DefaultPersistentSessionsManager(database=db)# Register the browsers this process "holds" — the reaper only touches these.held = owned_ids if owned_ids is not None else [s.persistent_browser_session_id for s in uncompleted_sessions]@@ -55,6 +79,28 @@ def _session()+def _real_session(+ session_id: str,+ started_minutes_ago: float | None,+ timeout_minutes: int | None,+ runnable_id: str | None = None,+ runnable_type: str | None = None,+) -> SimpleNamespace:+ """A row carrying only the fields the reaper reads. A MagicMock row auto-creates whatever+ attribute a gate checks, which makes a guard test pass without the guard existing."""+ started_at = None+ if started_minutes_ago is not None:+ started_at = datetime.now(timezone.utc) - timedelta(minutes=started_minutes_ago)+ return SimpleNamespace(+ persistent_browser_session_id=session_id,+ organization_id="org_test",+ started_at=started_at,+ timeout_minutes=timeout_minutes,+ runnable_id=runnable_id,+ runnable_type=runnable_type,+ )++def _workflow_run(status: WorkflowRunStatus) -> MagicMock:# Real WorkflowRunStatus so .is_final() runs the production logic, not a mocked truth value.return MagicMock(status=status)@@ -223,16 +269,18 @@ async def test_does_not_reap_terminal_owned_session_before_expiry() -> None:@pytest.mark.asyncio-async def test_protects_expired_session_with_unknown_runnable_type() -> None:- # A runnable_id set with a runnable_type the reaper can't authoritatively resolve stays protected:- # no broad age-only fallback, so this is left to its owner's teardown rather than reaped.[email protected]("unresolvable_type", ["script", "task_v2", None])+async def test_reaps_expired_session_with_unresolvable_runnable_type(unresolvable_type: str | None) -> None:+ # An owner type the reaper can't resolve (script today, any new runnable type tomorrow) used to+ # pin its session forever: no owner lookup exists, so it was treated as live on every pass. It+ # now gets no liveness protection and falls through to the ordinary timeout+grace gate.sessions = [- _session(- "pbs_unknown",+ _real_session(+ "pbs_unresolvable",started_minutes_ago=180,timeout_minutes=60,- runnable_id="tsk_unknown",- runnable_type="task_v2",+ runnable_id="s_dead",+ runnable_type=unresolvable_type,)]manager = _make_manager(sessions)@@ -240,8 +288,131 @@ async def test_protects_expired_session_with_unknown_runnable_type() -> None:await manager.reap_expired_sessions()- manager.close_session.assert_not_awaited()+ manager.close_session.assert_awaited_once_with("org_test", "pbs_unresolvable")+ # No per-type liveness semantics were invented: neither known-owner lookup was attempted.manager.database.workflow_runs.get_workflow_run.assert_not_awaited()+ manager.database.tasks.get_task.assert_not_awaited()+++async def test_protects_expired_session_leased_by_a_live_in_process_runnable(+ browser_manager: RealBrowserManager,+) -> None:+ # Nothing renews a standalone script's session, so a script running longer than its session+ # timeout would lose its browser mid-run — the case workflow_run/task owners survive via their+ # liveness lookup. The lease this process holds is that signal for an unresolvable owner.+ sessions = [+ _real_session(+ "pbs_leased",+ started_minutes_ago=180,+ timeout_minutes=60,+ runnable_id="s_running",+ runnable_type="script",+ )+ ]+ manager = _make_manager(sessions)+ manager.close_session = AsyncMock()+ _lease(browser_manager, "s_running", "pbs_leased")++ await manager.reap_expired_sessions()++ manager.close_session.assert_not_awaited()+++async def test_protects_expired_session_while_a_runnable_is_still_acquiring_it(+ browser_manager: RealBrowserManager,+) -> None:+ # begin_session publishes occupancy before the lease exists, so an expired session being reused+ # would otherwise be reapable for the whole attach and fail the run it was just handed to.+ sessions = [+ _real_session(+ "pbs_attaching",+ started_minutes_ago=180,+ timeout_minutes=60,+ runnable_id="s_attaching",+ runnable_type="script",+ )+ ]+ manager = _make_manager(sessions)+ manager.close_session = AsyncMock()+ browser_manager._acquiring_session_runnables.add("s_attaching")++ await manager.reap_expired_sessions()++ manager.close_session.assert_not_awaited()+++async def test_reaps_expired_session_once_its_lease_is_released(browser_manager: RealBrowserManager) -> None:+ # The lease is dropped at the run's terminal boundary, which is what makes the protection above+ # self-clearing rather than the indefinite protection this PR removes.+ sessions = [+ _real_session(+ "pbs_released",+ started_minutes_ago=180,+ timeout_minutes=60,+ runnable_id="s_done",+ runnable_type="script",+ )+ ]+ manager = _make_manager(sessions)+ manager.close_session = AsyncMock()+ _lease(browser_manager, "s_done", "pbs_released")++ await manager.reap_expired_sessions()+ manager.close_session.assert_not_awaited()++ browser_manager._persistent_session_leases.pop("s_done")+ await manager.reap_expired_sessions()++ manager.close_session.assert_awaited_once_with("org_test", "pbs_released")+++async def test_lease_does_not_protect_a_session_owned_by_a_terminal_workflow_run(+ browser_manager: RealBrowserManager,+) -> None:+ # Resolvable owners keep their existing contract: the DB verdict decides, and a lingering lease+ # for a terminal run must not start protecting a session the reaper already reclaims today.+ sessions = [+ _real_session(+ "pbs_wr_dead",+ started_minutes_ago=180,+ timeout_minutes=60,+ runnable_id="wr_dead",+ runnable_type=RunType.workflow_run,+ )+ ]+ manager = _make_manager(sessions)+ manager.database.workflow_runs.get_workflow_run = AsyncMock(return_value=_workflow_run(WorkflowRunStatus.failed))+ manager.close_session = AsyncMock()+ _lease(browser_manager, "wr_dead", "pbs_wr_dead")++ await manager.reap_expired_sessions()++ manager.close_session.assert_awaited_once_with("org_test", "pbs_wr_dead")+++async def test_does_not_reap_unresolvable_owner_before_timeout() -> None:+ # The fall-through hands unresolvable owners to the timeout+grace gate, not to an unconditional+ # reap: still inside its window, a script-owned session is untouched.+ sessions = [+ _real_session(+ "pbs_script_live",+ started_minutes_ago=1,+ timeout_minutes=60,+ runnable_id="s_live",+ runnable_type="script",+ )+ ]+ manager = _make_manager(sessions)+ manager.close_session = AsyncMock()++ await manager.reap_expired_sessions()++ manager.close_session.assert_not_awaited()@pytest.mark.asyncio@@ -563,21 +734,52 @@ async def test_reconcile_reclaims_completed_row_whose_owning_run_is_dead() -> No@pytest.mark.asyncio-async def test_reconcile_protects_completed_row_with_unknown_owner_type() -> None:- # An owner we can't authoritatively resolve (unrecognized runnable type) is treated as active, so- # reconcile never reclaims a session we can't prove is unowned — same fail-safe as the reaper.+async def test_reconcile_reclaims_completed_row_with_unresolvable_owner_type() -> None:+ # Same fall-through as the reaper: an owner type we can't resolve no longer protects the row, so a+ # completed row left occupied by a script run is reclaimed instead of leaking its local state.manager = _make_manager([], owned_ids=[])- _hold_local_session(manager, "pbs_unknown_owner")- row = _completed_row("pbs_unknown_owner")- row.runnable_id = "task_1"- row.runnable_type = "task_run"+ _hold_local_session(manager, "pbs_unresolvable_owner")+ row = SimpleNamespace(+ persistent_browser_session_id="pbs_unresolvable_owner",+ organization_id="org_test",+ completed_at=datetime.now(timezone.utc),+ status="completed",+ runnable_id="s_dead",+ runnable_type="script",+ should_export_profile=lambda: True,+ )+ manager.database.browser_sessions.get_persistent_browser_session = AsyncMock(return_value=row)+ manager._release_local_browser_session = AsyncMock()++ await manager.reconcile_local_sessions()++ manager._release_local_browser_session.assert_awaited_once_with(+ "org_test", "pbs_unresolvable_owner", export_profile=True+ )+++async def test_reconcile_leaves_active_row_with_unresolvable_owner_type() -> None:+ # Reconcile's own gate still governs after the fall-through: a live, uncompleted row is left to+ # ordinary expiration even though its owner type is unresolvable.+ manager = _make_manager([], owned_ids=[])+ _hold_local_session(manager, "pbs_unresolvable_live")+ row = SimpleNamespace(+ persistent_browser_session_id="pbs_unresolvable_live",+ organization_id="org_test",+ completed_at=None,+ status="running",+ runnable_id="s_live",+ runnable_type="script",+ should_export_profile=lambda: True,+ )manager.database.browser_sessions.get_persistent_browser_session = AsyncMock(return_value=row)manager._release_local_browser_session = AsyncMock()await manager.reconcile_local_sessions()manager._release_local_browser_session.assert_not_awaited()- assert "pbs_unknown_owner" in manager._browser_sessions+ assert "pbs_unresolvable_live" in manager._browser_sessions@pytest.mark.asynciodiff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex fda95d793..55e55c3ae 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -12,6 +12,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytest+from skyvern.exceptions import MissingBrowserStateForBrowserSessionfrom skyvern.forge.sdk.artifact.storage.recording_test_helpers import fake_prepared_recordingfrom skyvern.forge.sdk.core import skyvern_contextfrom skyvern.forge.sdk.core.skyvern_context import SkyvernContext@@ -1081,6 +1082,105 @@ async def test_public_workflow_cleanup_installs_closing_tombstone_before_first_aassert attached is False+async def test_script_acquisition_reports_a_live_session_before_the_lease_exists() -> None:+ # begin_session publishes occupancy, but the lease only lands once the attach returns — and occupy+ # does not extend started_at/timeout_minutes. A reused session already past timeout+grace would+ # therefore sit occupied-but-unleased for the whole attach, and the reaper (which reads liveness+ # from this manager) would reap it out from under the run.+ manager = RealBrowserManager()+ pbs_state = MagicMock()+ pbs_state.get_working_page = AsyncMock(return_value=None)+ pbs_state.get_or_create_page = AsyncMock()+ during_attach: list[set[str]] = []++ async def _begin_session(**kwargs: object) -> str:+ during_attach.append(manager.live_session_runnable_ids())+ return "gen_attach"++ async def _get_browser_state(*args: object, **kwargs: object) -> MagicMock:+ during_attach.append(manager.live_session_runnable_ids())+ return pbs_state++ with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ configure_browser_context_acquired_hook(mock_app)+ mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(side_effect=_begin_session)+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=_get_browser_state)++ await manager.get_or_create_for_script(+ script_id="s_attach",+ browser_session_id="pbs_attach",+ organization_id="org_test",+ )++ assert during_attach == [{"s_attach"}, {"s_attach"}]+ # The lease takes over with no gap once the attach completes.+ assert manager._persistent_session_leases["s_attach"].runnable_id == "s_attach"+ assert manager.live_session_runnable_ids() == {"s_attach"}+++async def test_failed_script_acquisition_leaves_no_live_session_behind() -> None:+ # A cold/evicted session fails closed. The in-flight marker must not outlive the attempt, or a run+ # that never started would protect the session from the reaper forever.+ manager = RealBrowserManager()++ with patch("skyvern.webeye.real_browser_manager.app") as mock_app:+ configure_browser_context_acquired_hook(mock_app)+ mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(return_value="gen_cold")+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)++ with pytest.raises(MissingBrowserStateForBrowserSession):+ await manager.get_or_create_for_script(+ script_id="s_cold",+ browser_session_id="pbs_cold",+ organization_id="org_test",+ )++ assert manager.live_session_runnable_ids() == set()+++ "release_outcome",+ [{"return_value": False}, {"side_effect": RuntimeError("db unreachable")}],+ ids=["cas_miss", "raises"],+)+async def test_script_cleanup_drops_lease_even_when_release_fails(+ monkeypatch: pytest.MonkeyPatch,+ release_outcome: dict,+) -> None:+ # Unlike a workflow run, a script's cleanup runs once at run_script's terminal boundary, so+ # nothing re-invokes it to retry a failed release — retaining the lease can only strand it. The+ # reaper reads that lease as "still running" and would skip the session forever, so drop the+ # lease either way and leave the still-occupied row to the reaper.+ script_id = "s_release_failed"+ manager = RealBrowserManager()+ browser_state = MagicMock()+ browser_state.browser_artifacts.traces_dir = None+ browser_state.close = AsyncMock(return_value=False)+ manager.pages[script_id] = browser_state+ manager._persistent_session_leases[script_id] = _PersistentSessionLease(+ session_id="pbs_release_failed",+ organization_id="org_test",+ runnable_id=script_id,+ browser_state=browser_state,+ )+ sessions = MagicMock()+ sessions.release_browser_session = AsyncMock(**release_outcome)+ monkeypatch.setattr(real_browser_manager, "app", MagicMock(PERSISTENT_SESSIONS_MANAGER=sessions))++ await manager.cleanup_for_script(+ script_id,+ close_browser_on_completion=False,+ browser_session_id="pbs_release_failed",+ organization_id="org_test",+ )++ assert script_id not in manager._persistent_session_leases+ sessions.release_browser_session.assert_awaited_once()++@pytest.mark.asyncioasync def test_public_workflow_cleanup_retains_owner_lease_until_release_succeeds(monkeypatch: pytest.MonkeyPatch,