Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
SKY-11061: fail closed on copilot download blocks that cannot register a real download (#6619)
Andrew Neilsonf1c559f91f5e
diff --git a/skyvern/forge/sdk/copilot/tools/workflow_update.py b/skyvern/forge/sdk/copilot/tools/workflow_update.pyindex 37948deb8..a80bea05f 100644--- a/skyvern/forge/sdk/copilot/tools/workflow_update.py+++ b/skyvern/forge/sdk/copilot/tools/workflow_update.py@@ -46,6 +46,7 @@ from skyvern.forge.sdk.copilot.output_policy import (format_output_policy_tool_error,output_policy_verdict_to_trace_data,)+from skyvern.forge.sdk.copilot.reached_download_target import REGISTERED_DOWNLOAD_OUTPUT_KEYSfrom skyvern.forge.sdk.copilot.runtime import AgentContext, ScoutedInteractionfrom skyvern.forge.sdk.copilot.streaming_adapter import emit_workflow_draft, maybe_emit_design_endfrom skyvern.forge.sdk.copilot.tracing_setup import copilot_span@@ -398,9 +399,13 @@ def _normalize_code_artifact_metadata_detailed(reject_unfilled_goal_value_paths=impose_defaults,))- return_shape_error = _extraction_return_shape_error(label, dumped, str(code_blocks[label].get("code") or ""))+ block_code = str(code_blocks[label].get("code") or "")+ return_shape_error = _extraction_return_shape_error(label, dumped, block_code)if return_shape_error is not None:item_violations.append(return_shape_error)+ download_shape_error = _download_return_shape_error(label, dumped, block_code)+ if download_shape_error is not None:+ item_violations.append(download_shape_error)if item_violations:violations.extend(item_violations)offending_labels.append(label)@@ -1525,6 +1530,8 @@ def _extraction_return_shape_error(label: str, artifact: Mapping[str, Any], codesignal; non-extraction blocks are never subject to this."""if not _artifact_declares_goal_values(artifact) or not code.strip():return None+ if _is_download_intent(artifact, code):+ return Noneif _code_block_returns_flat_string(code):return (f"Code block `{label}` declares `goal_value_paths` but `return`s a flat text blob "@@ -1543,6 +1550,110 @@ def _extraction_return_shape_error(label: str, artifact: Mapping[str, Any], codereturn None+_EXPECT_DOWNLOAD_ATTR = "expect_download"+++def _call_is_expect_download(node: ast.expr) -> bool:+ if isinstance(node, ast.Await):+ return _call_is_expect_download(node.value)+ if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):+ return node.func.attr == _EXPECT_DOWNLOAD_ATTR+ return False+++def _code_uses_expect_download(code: str) -> bool:+ """True only for the registering form: `expect_download()` called as the context+ expression of an `async with`/`with`. A bare `page.expect_download` attribute or an+ uncaptured call fires no download, so it does not count."""+ try:+ tree = ast.parse(textwrap.dedent(code).strip() or "pass")+ except SyntaxError:+ return False+ for node in ast.walk(tree):+ if isinstance(node, (ast.AsyncWith, ast.With)):+ for item in node.items:+ if _call_is_expect_download(item.context_expr):+ return True+ return False+++def _dict_keys(node: ast.expr) -> set[str]:+ if isinstance(node, ast.Await):+ return _dict_keys(node.value)+ if not isinstance(node, ast.Dict):+ return set()+ return {key.value for key in node.keys if isinstance(key, ast.Constant) and isinstance(key.value, str)}+++_REGISTERED_DOWNLOAD_OUTPUT_KEY_SET = frozenset(REGISTERED_DOWNLOAD_OUTPUT_KEYS)+++def _code_returns_registration_keys(code: str) -> bool:+ """True when a top-level `return`/binding emits a dict literal carrying any+ execution-layer-owned registration key; writing those keys self-certifies a+ download the runtime never observed."""+ try:+ tree = ast.parse(textwrap.dedent(code).strip() or "pass")+ except SyntaxError:+ return False+ for node in _iter_top_level_scope(tree.body):+ if isinstance(node, ast.Return) and node.value is not None:+ if _dict_keys(node.value) & _REGISTERED_DOWNLOAD_OUTPUT_KEY_SET:+ return True+ if isinstance(node, ast.Assign):+ if _dict_keys(node.value) & _REGISTERED_DOWNLOAD_OUTPUT_KEY_SET:+ return True+ return False+++def _artifact_declares_registration_keys(artifact: Mapping[str, Any]) -> bool:+ for field_name in ("claimed_outcomes", "terminal_verifier_expectations"):+ for row in _artifact_rows(artifact.get(field_name)):+ for path in _artifact_goal_value_paths(row.get("goal_value_paths")):+ head = path.split(".", 1)[0].split("[", 1)[0].strip()+ if head in _REGISTERED_DOWNLOAD_OUTPUT_KEY_SET:+ return True+ return False+++def _is_download_intent(artifact: Mapping[str, Any], code: str) -> bool:+ """Disjoint from extraction-intent (`goal_value_paths` on non-registration keys):+ a block is download-intent when it carries the expect_download idiom, self-asserts a+ registration key in a top-level dict, or declares a registration key as a goal path."""+ if not code.strip():+ return False+ return (+ _code_uses_expect_download(code)+ or _code_returns_registration_keys(code)+ or _artifact_declares_registration_keys(artifact)+ )+++def _download_return_shape_error(label: str, artifact: Mapping[str, Any], code: str) -> str | None:+ """Fail closed on a download-intent code block that cannot register a real download:+ one lacking the `page.expect_download` idiom (no browser download ever fires), or one+ whose return writes the execution-layer-owned registration keys (self-certification)."""+ if not _is_download_intent(artifact, code):+ return None+ if not _code_uses_expect_download(code):+ return (+ f"Code block `{label}` is a download block but does not fire the browser download with the "+ "`page.expect_download` idiom (async with page.expect_download() as dl_info: await "+ "page.click(<unique selector>)). A static fetch or a plain click registers no file. Author the "+ "expect_download idiom against a unique target so the runtime registers the file into the workflow "+ "output (downloaded_files); never place file bytes or URLs in the chat reply."+ )+ if _code_returns_registration_keys(code):+ return (+ f"Code block `{label}` `return`s the download registration keys "+ f"({', '.join(REGISTERED_DOWNLOAD_OUTPUT_KEYS)}) itself. The execution layer injects those keys when a "+ "browser download fires; writing them self-certifies a download that may never have happened. Return a "+ 'small keyed descriptor instead (for example `return {"saved_as": dl_info.value.suggested_filename}`) and '+ "let the expect_download idiom register the file."+ )+ return None++def _code_artifact_metadata_shape_errors(label: str,artifact: Mapping[str, Any],diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.pyindex 170739e6f..55dceda68 100644--- a/skyvern/forge/sdk/workflow/models/block.py+++ b/skyvern/forge/sdk/workflow/models/block.py@@ -154,6 +154,7 @@ from skyvern.utils.token_counter import count_tokensfrom skyvern.utils.url_validators import prepend_scheme_and_validate_urlfrom skyvern.webeye.actions.action_types import ActionTypefrom skyvern.webeye.actions.actions import Action, ActionStatus+from skyvern.webeye.browser_factory import rebind_download_dirfrom skyvern.webeye.browser_state import BrowserStatefrom skyvern.webeye.utils.page import SkyvernFrame@@ -466,6 +467,24 @@ class Block(BaseModel, abc.ABC):if browser_session_id and organization_id:browser_state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(browser_session_id, organization_id)+ if browser_state is not None:+ adopted_context = browser_state.browser_context+ adopted_browser = adopted_context.browser if adopted_context else None+ if adopted_browser is not None:+ try:+ await rebind_download_dir(adopted_browser, run_id=workflow_run_id)+ LOG.info(+ "Rebound download dir on adopted persistent session",+ browser_session_id=browser_session_id,+ workflow_run_id=workflow_run_id,+ )+ except Exception:+ LOG.warning(+ "Failed to rebind download dir on adopted persistent session",+ browser_session_id=browser_session_id,+ workflow_run_id=workflow_run_id,+ exc_info=True,+ )else:browser_state = app.BROWSER_MANAGER.get_for_workflow_run(workflow_run_id)diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.pyindex 7885f6c98..fcb5f71b7 100644--- a/skyvern/webeye/browser_factory.py+++ b/skyvern/webeye/browser_factory.py@@ -179,8 +179,9 @@ def set_download_file_listener(browser_context: BrowserContext, download_timeout: float | None = None, **kwargs: Any) -> None:async def listen_to_download(download: Download) -> None:- workflow_run_id = kwargs.get("workflow_run_id")- task_id = kwargs.get("task_id")+ context = current()+ workflow_run_id = (context.workflow_run_id if context else None) or kwargs.get("workflow_run_id")+ task_id = (context.task_id if context else None) or kwargs.get("task_id")try:async with asyncio.timeout(download_timeout or BROWSER_DOWNLOAD_TIMEOUT):file_path = await download.path()@@ -259,11 +260,8 @@ def initialize_download_dir() -> str:)-async def _apply_download_behaviour(browser: Browser) -> None:- context = ensure_context()- download_dir = get_download_dir(- context.run_id if context and context.run_id else context.workflow_run_id or context.task_id- )+async def rebind_download_dir(browser: Browser, run_id: str | None) -> None:+ download_dir = get_download_dir(run_id)cdp_session = await browser.new_browser_cdp_session()await cdp_session.send("Browser.setDownloadBehavior",@@ -273,7 +271,13 @@ async def _apply_download_behaviour(browser: Browser) -> None:},)- LOG.info("setDownloadBehavior applied", download_dir=download_dir)+ LOG.info("setDownloadBehavior applied", download_dir=download_dir, run_id=run_id)+++async def _apply_download_behaviour(browser: Browser) -> None:+ context = ensure_context()+ run_id = context.run_id if context and context.run_id else context.workflow_run_id or context.task_id+ await rebind_download_dir(browser, run_id)class BrowserContextCreator(Protocol):diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex 247309222..28f29d766 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -11,7 +11,7 @@ from skyvern.forge.sdk.schemas.tasks import Taskfrom skyvern.forge.sdk.workflow.models.workflow import WorkflowRunfrom skyvern.schemas.runs import ProxyLocation, ProxyLocationInputfrom skyvern.webeye.browser_artifacts import VideoArtifact-from skyvern.webeye.browser_factory import BrowserContextFactory+from skyvern.webeye.browser_factory import BrowserContextFactory, rebind_download_dirfrom skyvern.webeye.browser_manager import BrowserManagerfrom skyvern.webeye.browser_state import BrowserStatefrom skyvern.webeye.real_browser_state import RealBrowserState@@ -210,6 +210,18 @@ class RealBrowserManager(BrowserManager):)else:LOG.info("Used to occupy browser session here", browser_session_id=browser_session_id)+ browser_context = browser_state.browser_context+ adopted_browser = browser_context.browser if browser_context else None+ if adopted_browser is not None:+ try:+ await rebind_download_dir(adopted_browser, run_id=workflow_run.workflow_run_id)+ except Exception:+ LOG.warning(+ "Failed to rebind download dir on adopted browser session",+ browser_session_id=browser_session_id,+ workflow_run_id=workflow_run.workflow_run_id,+ exc_info=True,+ )page = await browser_state.get_working_page()if page:if url and navigate:diff --git a/tests/unit/test_copilot_code_artifact_metadata_violations.py b/tests/unit/test_copilot_code_artifact_metadata_violations.pyindex ff35e05a4..9bccae589 100644--- a/tests/unit/test_copilot_code_artifact_metadata_violations.py+++ b/tests/unit/test_copilot_code_artifact_metadata_violations.py@@ -997,3 +997,131 @@ class TestViolationBatchIsDurablyRecoverable:assert span.attrs["copilot.code_artifact_violations"] == ["only_one"]assert span.attrs["copilot.code_artifact_violation_count"] == 1assert span.attrs["copilot.code_artifact_violation_block_labels"] == ["b"]+++def _download_intent_metadata(label: str) -> dict:+ metadata = _non_extraction_metadata(label)+ metadata["claimed_outcomes"][0]["goal_value_paths"] = ["downloaded_files"]+ metadata["terminal_verifier_expectations"][0]["goal_value_paths"] = ["downloaded_files"]+ return metadata+++class TestDownloadReturnShape:+ def test_expect_download_idiom_with_descriptor_passes(self) -> None:+ code = """+ async with page.expect_download() as dl_info:+ await page.click("a#statement-pdf")+ return {"saved_as": dl_info.value.suggested_filename}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_download_intent_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert error is None+ assert list(normalized.keys()) == ["dl_block"]++ def test_self_asserted_keys_without_idiom_is_rejected(self) -> None:+ code = """+ await page.click("a#statement-pdf")+ return {"downloaded_files": ["/tmp/statement.pdf"]}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_download_intent_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert normalized == {}+ assert error is not None+ assert "expect_download" in error++ def test_plain_click_fabricated_dict_is_rejected(self) -> None:+ code = """+ await page.click("a#statement-pdf")+ return {"downloaded_file_name": "statement.pdf", "evidence": "ok"}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_download_intent_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert normalized == {}+ assert error is not None+ assert "expect_download" in error++ def test_static_fetch_body_is_rejected(self) -> None:+ code = """+ import requests+ body = requests.get("https://example.com/statement.pdf").content+ return {"downloaded_files": [body]}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_download_intent_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert normalized == {}+ assert error is not None+ assert "expect_download" in error++ def test_idiom_but_returns_registration_keys_is_rejected(self) -> None:+ code = """+ async with page.expect_download() as dl_info:+ await page.click("a#statement-pdf")+ return {"downloaded_files": [await dl_info.value.path()]}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_download_intent_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert normalized == {}+ assert error is not None+ assert "downloaded_files" in error+ assert "self-certifies" in error++ def test_self_asserted_keys_detected_without_goal_path_declaration(self) -> None:+ code = """+ await page.click("a#statement-pdf")+ return {"downloaded_files": ["/tmp/statement.pdf"]}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_non_extraction_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert normalized == {}+ assert error is not None+ assert "expect_download" in error++ def test_extraction_block_is_not_treated_as_download_intent(self) -> None:+ code = """+ await page.goto("https://example.com/")+ return {"records": [{"number": "1"}]}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_extraction_metadata("ex_block", ["records[].number"])],+ _extraction_code_block_yaml("ex_block", code),+ )+ assert error is None+ assert list(normalized.keys()) == ["ex_block"]++ def test_bare_expect_download_attribute_does_not_satisfy_the_idiom(self) -> None:+ code = """+ _ = page.expect_download+ await page.click("a#statement-pdf")+ return {"downloaded_files": ["/tmp/statement.pdf"]}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_download_intent_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert normalized == {}+ assert error is not None+ assert "expect_download" in error++ def test_non_download_non_extraction_block_passes(self) -> None:+ code = """+ await page.click("a#statement-pdf")+ return {"clicked": True}+ """+ normalized, error = _normalize_code_artifact_metadata(+ [_non_extraction_metadata("dl_block")],+ _extraction_code_block_yaml("dl_block", code),+ )+ assert error is None+ assert list(normalized.keys()) == ["dl_block"]diff --git a/tests/unit/test_download_dir_rebind.py b/tests/unit/test_download_dir_rebind.pynew file mode 100644index 000000000..c9104ead4--- /dev/null+++ b/tests/unit/test_download_dir_rebind.py@@ -0,0 +1,245 @@+"""Run-scoped download dir binding for adopted persistent sessions (SKY-11083).++A persistent browser session launched outside any run context binds its CDP+downloadPath to downloads/None/. When a workflow run later adopts that session,+the dir must be rebound to downloads/<workflow_run_id>/ so downloads land+run-scoped and the listener logs the real run identity.+"""++from unittest.mock import AsyncMock, MagicMock, patch++import pytest++from skyvern.forge.sdk.api.files import get_download_dir+from skyvern.forge.sdk.core.skyvern_context import SkyvernContext+from skyvern.webeye.browser_factory import (+ _apply_download_behaviour,+ rebind_download_dir,+ set_download_file_listener,+)+++def _recording_browser() -> tuple[MagicMock, MagicMock]:+ cdp_session = MagicMock()+ cdp_session.send = AsyncMock()+ browser = MagicMock()+ browser.new_browser_cdp_session = AsyncMock(return_value=cdp_session)+ return browser, cdp_session+++async def test_rebind_binds_download_path_to_run_dir() -> None:+ browser, cdp_session = _recording_browser()++ await rebind_download_dir(browser, run_id="wr_test")++ cdp_session.send.assert_awaited_once()+ method, params = cdp_session.send.await_args.args+ assert method == "Browser.setDownloadBehavior"+ assert params["downloadPath"] == get_download_dir("wr_test")+ assert "None" not in params["downloadPath"]+++async def test_apply_download_behaviour_uses_run_id_first_resolution() -> None:+ browser, cdp_session = _recording_browser()+ ctx = SkyvernContext(run_id="run_x", workflow_run_id="wr_y", task_id="t_z")++ with patch("skyvern.webeye.browser_factory.ensure_context", return_value=ctx):+ await _apply_download_behaviour(browser)++ _, params = cdp_session.send.await_args.args+ assert params["downloadPath"] == get_download_dir("run_x")+++async def test_apply_download_behaviour_falls_back_to_workflow_run_id() -> None:+ browser, cdp_session = _recording_browser()+ ctx = SkyvernContext(run_id=None, workflow_run_id="wr_y", task_id="t_z")++ with patch("skyvern.webeye.browser_factory.ensure_context", return_value=ctx):+ await _apply_download_behaviour(browser)++ _, params = cdp_session.send.await_args.args+ assert params["downloadPath"] == get_download_dir("wr_y")+++async def test_listener_logs_run_identity_from_context() -> None:+ captured: dict[str, object] = {}++ def capture_log(_msg: str, **kwargs: object) -> None:+ captured.update(kwargs)++ download = MagicMock()+ download.suggested_filename = "statement.pdf"+ download.url = "https://example.com/d"+ path = MagicMock()+ path.suffix = ""+ download.path = AsyncMock(return_value=path)++ captured_handler: dict[str, object] = {}++ def on_page(_event: str, handler: object) -> None:+ captured_handler["handler"] = handler++ browser_context = MagicMock()+ browser_context.on = on_page++ set_download_file_listener(browser_context)++ page = MagicMock()+ page_handlers: dict[str, object] = {}+ page.on = lambda _event, handler: page_handlers.setdefault("download", handler)+ captured_handler["handler"](page)++ ctx = SkyvernContext(workflow_run_id="wr_real", task_id="task_real")+ with (+ patch("skyvern.webeye.browser_factory.current", return_value=ctx),+ patch("skyvern.webeye.browser_factory.LOG.info", side_effect=capture_log),+ ):+ await page_handlers["download"](download)++ assert captured.get("workflow_run_id") == "wr_real"+ assert captured.get("task_id") == "task_real"+++async def test_listener_falls_back_to_kwargs_without_context() -> None:+ captured: dict[str, object] = {}++ def capture_log(_msg: str, **kwargs: object) -> None:+ captured.update(kwargs)++ download = MagicMock()+ download.suggested_filename = "statement.pdf"+ download.url = "https://example.com/d"+ path = MagicMock()+ path.suffix = ""+ download.path = AsyncMock(return_value=path)++ captured_handler: dict[str, object] = {}+ browser_context = MagicMock()+ browser_context.on = lambda _event, handler: captured_handler.setdefault("handler", handler)++ set_download_file_listener(browser_context, workflow_run_id="wr_kwarg", task_id="task_kwarg")++ page = MagicMock()+ page_handlers: dict[str, object] = {}+ page.on = lambda _event, handler: page_handlers.setdefault("download", handler)+ captured_handler["handler"](page)++ with (+ patch("skyvern.webeye.browser_factory.current", return_value=None),+ patch("skyvern.webeye.browser_factory.LOG.info", side_effect=capture_log),+ ):+ await page_handlers["download"](download)++ assert captured.get("workflow_run_id") == "wr_kwarg"+ assert captured.get("task_id") == "task_kwarg"+++async def test_block_adoption_seam_rebinds_to_run_dir() -> None:+ """The copilot code-block acquisition site rebinds the adopted CDP downloadPath to the run dir (SKY-11083)."""+ from skyvern.forge.sdk.workflow.models.block import Block++ browser, cdp_session = _recording_browser()+ browser_state = MagicMock()+ browser_state.browser_context.browser = browser++ with patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app:+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)+ mock_app.BROWSER_MANAGER.get_or_create_for_workflow_run = AsyncMock()++ result = await Block.get_or_create_browser_state(+ MagicMock(),+ workflow_run_id="wr_block",+ organization_id="org_1",+ browser_session_id="bs_block",+ )++ assert result is browser_state+ _, params = cdp_session.send.await_args.args+ assert params["downloadPath"] == get_download_dir("wr_block")+ assert params["downloadPath"].endswith("/wr_block")+ mock_app.BROWSER_MANAGER.get_or_create_for_workflow_run.assert_not_called()+++async def test_block_adoption_seam_skips_rebind_without_browser() -> None:+ """No owning Browser on the adopted context -> skip the rebind, still return the state."""+ from skyvern.forge.sdk.workflow.models.block import Block++ browser_state = MagicMock()+ browser_state.browser_context.browser = None++ with (+ patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app,+ patch("skyvern.forge.sdk.workflow.models.block.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,+ ):+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)++ result = await Block.get_or_create_browser_state(+ MagicMock(),+ workflow_run_id="wr_block",+ organization_id="org_1",+ browser_session_id="bs_block",+ )++ assert result is browser_state+ mock_rebind.assert_not_awaited()+++async def test_block_own_browser_path_does_not_rebind() -> None:+ """Own-browser acquisition (no browser_session_id) runs zero rebind code (SKY-11083 regression guard)."""+ from skyvern.forge.sdk.workflow.models.block import Block++ browser_state = MagicMock()++ with (+ patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app,+ patch("skyvern.forge.sdk.workflow.models.block.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,+ ):+ mock_app.BROWSER_MANAGER.get_for_workflow_run = MagicMock(return_value=browser_state)++ result = await Block.get_or_create_browser_state(+ MagicMock(),+ workflow_run_id="wr_own",+ organization_id=None,+ browser_session_id=None,+ )++ assert result is browser_state+ mock_rebind.assert_not_awaited()+++async def test_block_adoption_seam_fail_open_on_rebind_error() -> None:+ """A rebind failure is swallowed; the block still receives its browser state (fail-open)."""+ from skyvern.forge.sdk.workflow.models.block import Block++ browser_state = MagicMock()+ browser_state.browser_context.browser = MagicMock()++ with (+ patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app,+ patch(+ "skyvern.forge.sdk.workflow.models.block.rebind_download_dir",+ new_callable=AsyncMock,+ side_effect=RuntimeError("cdp down"),+ ),+ ):+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)+ mock_app.BROWSER_MANAGER.get_or_create_for_workflow_run = AsyncMock()++ result = await Block.get_or_create_browser_state(+ MagicMock(),+ workflow_run_id="wr_block",+ organization_id="org_1",+ browser_session_id="bs_block",+ )++ assert result is browser_state+ mock_app.BROWSER_MANAGER.get_or_create_for_workflow_run.assert_not_called()diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex 9a830060a..21590e58f 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -518,3 +518,78 @@ async def test_cleanup_persists_session_cookies_when_close_deferred_for_streams(persist_mock.assert_awaited_once_with(browser_state.browser_context, "/tmp/fake_profile")browser_state.close.assert_not_awaited()+++async def test_pbs_adoption_rebinds_download_dir_to_run_id() -> None:+ """Adopting a persistent session must rebind its CDP download dir to the run's id (SKY-11083)."""+ manager = RealBrowserManager()+ workflow_run = make_workflow_run("wfr_adopt")++ adopted_browser = MagicMock()+ pbs_state = MagicMock()+ pbs_state.browser_context.browser = adopted_browser+ pbs_state.get_working_page = AsyncMock(return_value=None)+ pbs_state.get_or_create_page = AsyncMock()++ with (+ patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,+ ):+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)+ mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()++ await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url=None,+ browser_session_id="bs_adopt",+ )++ mock_rebind.assert_awaited_once_with(adopted_browser, run_id="wfr_adopt")+++async def test_pbs_adoption_skips_rebind_when_no_browser() -> None:+ """Rebind must no-op when the adopted context exposes no owning browser (e.g. launch_persistent_context)."""+ manager = RealBrowserManager()+ workflow_run = make_workflow_run("wfr_no_browser")++ pbs_state = MagicMock()+ pbs_state.browser_context.browser = None+ pbs_state.get_working_page = AsyncMock(return_value=None)+ pbs_state.get_or_create_page = AsyncMock()++ with (+ patch("skyvern.webeye.real_browser_manager.app") as mock_app,+ patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,+ ):+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)+ mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()++ await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url=None,+ browser_session_id="bs_no_browser",+ )++ mock_rebind.assert_not_awaited()+++async def test_non_pbs_workflow_run_does_not_rebind() -> None:+ """The own-browser (no browser_session_id) path must run zero new download-rebind code (SKY-11083 regression guard)."""+ manager = RealBrowserManager()+ parent_state = MagicMock()+ manager.pages["wfr_parent"] = parent_state++ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")++ with patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind:+ result = await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url=None,+ browser_session_id=None,+ )++ assert result is parent_state+ mock_rebind.assert_not_awaited()