Skip to content

Automate browser based workflows with AI

fix(SKY-11086): don't serve unfinalized per-run recording for session runs (#6641)

Aaron Perez3a0ec0010c51
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index e5ae35ae0..5598b9c44 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -3737,8 +3737,12 @@ async def wrapper({default_args}):
workflow_run_id: str,
workflow_run_block_id: str,
organization_id: str | None,
+ browser_session_id: str | None = None,
) -> None:
- """Register the run-scoped RECORDING row that a code block otherwise lacks so the recording is reachable."""
+ """Register the run-scoped RECORDING row a fresh-browser code block otherwise lacks; no-op when the
+ browser stays open on completion (persistent session or pinned browser_address)."""
+ if browser_session_id:
+ return
# get_video_artifacts returns the same VideoArtifact objects held on browser_state, so the id
# written below is observed by the early-return guard on later blocks sharing the browser.
# Idempotency assumes those blocks run sequentially (no concurrent first-time registration).
@@ -3746,6 +3750,11 @@ async def wrapper({default_args}):
if not browser_artifacts or all(va.video_artifact_id for va in browser_artifacts.video_artifacts):
return
try:
+ # A pinned browser_address run also keeps its browser open, so its per-run webm never
+ # finalizes — skip it like a session run and let the clip path serve the recording.
+ workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(workflow_run_id, organization_id)
+ if workflow_run is not None and workflow_run.browser_address:
+ return
video_artifacts = await app.BROWSER_MANAGER.get_video_artifacts(
workflow_run_id=workflow_run_id, browser_state=browser_state, finalize=False
)
@@ -3920,6 +3929,7 @@ async def wrapper({default_args}):
workflow_run_id=workflow_run_id,
workflow_run_block_id=workflow_run_block_id,
organization_id=organization_id,
+ browser_session_id=browser_session_id,
)
try:
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index e85fb8d61..22e8f4b29 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -5668,9 +5668,18 @@ class WorkflowService:
except asyncio.TimeoutError:
LOG.warning("Timeout getting recordings", browser_session_id=workflow_run.browser_session_id)
- # Last resort: a run's own recording — a non-session task recording, or a session run
- # whose clip and finalized session recording are both unavailable.
- if not recording_urls and not recording_archived and run_recording_artifacts and not clip_artifacts:
+ # Last resort: a run's own recording, only when its browser closes on completion. A run that
+ # keeps its browser open (persistent session or pinned browser_address) never finalizes its
+ # per-run webm, so it has no Duration/Cues and won't play; the clip / session-recording paths
+ # above cover those runs instead.
+ closes_on_completion = not workflow_run.browser_session_id and not workflow_run.browser_address
+ if (
+ not recording_urls
+ and not recording_archived
+ and run_recording_artifacts
+ and not clip_artifacts
+ and closes_on_completion
+ ):
recording_archived = await app.ARTIFACT_MANAGER.is_recording_archived(run_recording_artifacts[0])
if not recording_archived:
urls = await app.ARTIFACT_MANAGER.get_share_links_with_bundle_support(run_recording_artifacts)
diff --git a/tests/unit/test_code_block_recording_artifact.py b/tests/unit/test_code_block_recording_artifact.py
index 2afe93567..f148ecb78 100644
--- a/tests/unit/test_code_block_recording_artifact.py
+++ b/tests/unit/test_code_block_recording_artifact.py
@@ -54,10 +54,12 @@ async def test_registers_run_scoped_recording_when_video_artifact_has_no_id() ->
get_video = AsyncMock(return_value=video_artifacts)
fake_block = SimpleNamespace(workflow_run_block_id="wrb_1", workflow_run_id="wr_1", organization_id="o_1")
get_block = AsyncMock(return_value=fake_block)
+ get_run = AsyncMock(return_value=SimpleNamespace(browser_address=None))
create_artifact = AsyncMock(return_value="a_recording")
with (
patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_BLOCK_PATH}.DATABASE.workflow_runs.get_workflow_run", get_run),
patch(f"{_BLOCK_PATH}.DATABASE.observer.get_workflow_run_block", get_block),
patch(f"{_BLOCK_PATH}.ARTIFACT_MANAGER.create_workflow_run_block_artifact", create_artifact),
):
@@ -80,6 +82,62 @@ async def test_registers_run_scoped_recording_when_video_artifact_has_no_id() ->
assert video_artifacts[0].video_artifact_id == "a_recording"
+async def test_skips_registration_for_persistent_session_run() -> None:
+ # A persistent/copilot session keeps the browser open on completion, so the per-run webm never
+ # finalizes (no Duration/Cues — it won't play). The clip path (sync_run_recording_clips) delivers
+ # the playable run-scoped MP4 at session close, so registering the unfinalized webm here would only
+ # produce a broken last-resort recording (SKY-11086). Skip it entirely for session runs.
+ video_artifacts = [VideoArtifact(video_path="/tmp/recording.webm", video_data=b"partial-video")]
+ browser_state = _browser_state(video_artifacts)
+ get_video = AsyncMock(return_value=video_artifacts)
+ create_artifact = AsyncMock()
+
+ with (
+ patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_BLOCK_PATH}.ARTIFACT_MANAGER.create_workflow_run_block_artifact", create_artifact),
+ ):
+ await _code_block()._ensure_run_recording_artifact(
+ browser_state=browser_state,
+ workflow_run_id="wr_1",
+ workflow_run_block_id="wrb_1",
+ organization_id="o_1",
+ browser_session_id="pbs_1",
+ )
+
+ get_video.assert_not_awaited()
+ create_artifact.assert_not_awaited()
+ assert video_artifacts[0].video_artifact_id is None
+
+
+async def test_skips_registration_for_pinned_browser_address_run() -> None:
+ # A run pinned to a remote browser via browser_address (no browser_session_id) also keeps its
+ # browser open on completion, so its per-run webm never finalizes — skip registration like a
+ # session run, mirroring close_browser_on_completion. The video is never read.
+ video_artifacts = [VideoArtifact(video_path="/tmp/recording.webm", video_data=b"partial-video")]
+ browser_state = _browser_state(video_artifacts)
+ get_run = AsyncMock(return_value=SimpleNamespace(browser_address="ws://browser.example:9222"))
+ get_video = AsyncMock(return_value=video_artifacts)
+ create_artifact = AsyncMock()
+
+ with (
+ patch(f"{_BLOCK_PATH}.DATABASE.workflow_runs.get_workflow_run", get_run),
+ patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_BLOCK_PATH}.ARTIFACT_MANAGER.create_workflow_run_block_artifact", create_artifact),
+ ):
+ await _code_block()._ensure_run_recording_artifact(
+ browser_state=browser_state,
+ workflow_run_id="wr_1",
+ workflow_run_block_id="wrb_1",
+ organization_id="o_1",
+ )
+
+ get_video.assert_not_awaited()
+ create_artifact.assert_not_awaited()
+ assert video_artifacts[0].video_artifact_id is None
+
+
@pytest.mark.asyncio
async def test_is_idempotent_when_video_artifact_already_registered() -> None:
video_artifacts = [VideoArtifact(video_path="/tmp/recording.webm", video_artifact_id="a_existing")]
@@ -130,6 +188,7 @@ async def test_artifact_failure_is_swallowed() -> None:
video_artifacts = [VideoArtifact(video_path="/tmp/recording.webm", video_data=b"partial-video")]
browser_state = _browser_state(video_artifacts)
get_video = AsyncMock(return_value=video_artifacts)
+ get_run = AsyncMock(return_value=SimpleNamespace(browser_address=None))
get_block = AsyncMock(
return_value=SimpleNamespace(workflow_run_block_id="wrb_1", workflow_run_id="wr_1", organization_id="o_1")
)
@@ -137,6 +196,7 @@ async def test_artifact_failure_is_swallowed() -> None:
with (
patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_BLOCK_PATH}.DATABASE.workflow_runs.get_workflow_run", get_run),
patch(f"{_BLOCK_PATH}.DATABASE.observer.get_workflow_run_block", get_block),
patch(f"{_BLOCK_PATH}.ARTIFACT_MANAGER.create_workflow_run_block_artifact", create_artifact),
):
@@ -159,11 +219,13 @@ async def test_second_call_skips_re_registration() -> None:
video_artifacts = [VideoArtifact(video_path="/tmp/recording.webm", video_data=b"partial-video")]
browser_state = _browser_state(video_artifacts)
get_video = AsyncMock(return_value=video_artifacts)
+ get_run = AsyncMock(return_value=SimpleNamespace(browser_address=None))
get_block = AsyncMock(return_value=SimpleNamespace(workflow_run_block_id="wrb_1"))
create_artifact = AsyncMock(return_value="a_recording")
with (
patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_BLOCK_PATH}.DATABASE.workflow_runs.get_workflow_run", get_run),
patch(f"{_BLOCK_PATH}.DATABASE.observer.get_workflow_run_block", get_block),
patch(f"{_BLOCK_PATH}.ARTIFACT_MANAGER.create_workflow_run_block_artifact", create_artifact),
):
@@ -190,11 +252,13 @@ async def test_registers_when_video_data_not_yet_captured() -> None:
assert video_artifacts[0].video_data == b""
browser_state = _browser_state(video_artifacts)
get_video = AsyncMock(return_value=video_artifacts)
+ get_run = AsyncMock(return_value=SimpleNamespace(browser_address=None))
get_block = AsyncMock(return_value=SimpleNamespace(workflow_run_block_id="wrb_1"))
create_artifact = AsyncMock(return_value="a_recording")
with (
patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_BLOCK_PATH}.DATABASE.workflow_runs.get_workflow_run", get_run),
patch(f"{_BLOCK_PATH}.DATABASE.observer.get_workflow_run_block", get_block),
patch(f"{_BLOCK_PATH}.ARTIFACT_MANAGER.create_workflow_run_block_artifact", create_artifact),
):
diff --git a/tests/unit/test_fetch_recording_urls.py b/tests/unit/test_fetch_recording_urls.py
index e376da90b..4926302e4 100644
--- a/tests/unit/test_fetch_recording_urls.py
+++ b/tests/unit/test_fetch_recording_urls.py
@@ -14,6 +14,7 @@ from skyvern.forge.sdk.workflow.service import WorkflowService
def _workflow_run() -> SimpleNamespace:
return SimpleNamespace(
browser_session_id="pbs_1",
+ browser_address=None,
started_at=datetime(2026, 6, 4, 16, 0, tzinfo=UTC),
finished_at=datetime(2026, 6, 4, 16, 30, tzinfo=UTC),
organization_id="o_1",
@@ -133,6 +134,58 @@ async def test_legacy_run_recording_does_not_preempt_session_recording(monkeypat
get_links.assert_not_awaited() # the legacy run recording is not served
+async def test_session_run_own_recording_not_served_when_unfinalized(monkeypatch) -> None:
+ # A browser-session run's own (non-clip) recording is never finalized — its browser stays
+ # open on completion, so the per-run webm has no Duration/Cues and won't play. It must NOT
+ # be served as a last resort; the clip / finalized session recording cover session runs once
+ # the session closes (SKY-11086: "recording shows up but the video doesn't work").
+ monkeypatch.setattr(
+ app.DATABASE.artifacts,
+ "list_artifacts_for_run_by_type",
+ AsyncMock(return_value=[_legacy_artifact()]),
+ raising=False,
+ )
+ monkeypatch.setattr(
+ app.STORAGE, "get_shared_recordings_in_browser_session", AsyncMock(return_value=[]), raising=False
+ )
+ get_links = AsyncMock(return_value=["legacy_url"])
+ monkeypatch.setattr(app.ARTIFACT_MANAGER, "get_share_links_with_bundle_support", get_links, raising=False)
+ monkeypatch.setattr(app.ARTIFACT_MANAGER, "is_recording_archived", AsyncMock(return_value=False), raising=False)
+
+ urls, archived = await _fetch(_workflow_run())
+
+ assert urls == []
+ assert archived is False
+ get_links.assert_not_awaited() # the unfinalized per-run recording is never served for a session run
+
+
+async def test_browser_address_run_own_recording_not_served_when_unfinalized(monkeypatch) -> None:
+ # Same invariant for a run pinned to a remote browser via browser_address (no browser_session_id):
+ # its browser also stays open on completion, so its own per-run recording never finalizes.
+ monkeypatch.setattr(
+ app.DATABASE.artifacts,
+ "list_artifacts_for_run_by_type",
+ AsyncMock(return_value=[_legacy_artifact()]),
+ raising=False,
+ )
+ get_session = AsyncMock(return_value=[])
+ monkeypatch.setattr(app.STORAGE, "get_shared_recordings_in_browser_session", get_session, raising=False)
+ get_links = AsyncMock(return_value=["legacy_url"])
+ monkeypatch.setattr(app.ARTIFACT_MANAGER, "get_share_links_with_bundle_support", get_links, raising=False)
+
+ run = _workflow_run()
+ run.browser_session_id = None
+ run.browser_address = "ws://browser.example:9222"
+
+ urls, archived = await _fetch(run)
+
+ assert urls == []
+ assert archived is False
+ get_links.assert_not_awaited()
+
+
@pytest.mark.asyncio
async def test_legacy_run_recording_served_for_non_session_run(monkeypatch) -> None:
# A non-session task run's own recording is the last resort (keeps normal task recordings working).