Skip to content

Automate browser based workflows with AI

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.py
index 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_KEYS
from skyvern.forge.sdk.copilot.runtime import AgentContext, ScoutedInteraction
from skyvern.forge.sdk.copilot.streaming_adapter import emit_workflow_draft, maybe_emit_design_end
from 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], code
signal; 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 None
if _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], code
return 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.py
index 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_tokens
from skyvern.utils.url_validators import prepend_scheme_and_validate_url
from skyvern.webeye.actions.action_types import ActionType
from skyvern.webeye.actions.actions import Action, ActionStatus
+from skyvern.webeye.browser_factory import rebind_download_dir
from skyvern.webeye.browser_state import BrowserState
from 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.py
index 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.py
index 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 Task
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRun
from skyvern.schemas.runs import ProxyLocation, ProxyLocationInput
from skyvern.webeye.browser_artifacts import VideoArtifact
-from skyvern.webeye.browser_factory import BrowserContextFactory
+from skyvern.webeye.browser_factory import BrowserContextFactory, rebind_download_dir
from skyvern.webeye.browser_manager import BrowserManager
from skyvern.webeye.browser_state import BrowserState
from 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.py
index 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"] == 1
assert 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.py
new file mode 100644
index 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.py
index 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()