Skip to content

Automate browser based workflows with AI

fix(SKY-11078): emit run-scoped recording artifact for code-block runs (#6607)

Aaron Perez250e3ba9bc4e
diff --git a/skyvern/forge/sdk/artifact/manager.py b/skyvern/forge/sdk/artifact/manager.py
index df620f72c..5c6f2b4b9 100644
--- a/skyvern/forge/sdk/artifact/manager.py
+++ b/skyvern/forge/sdk/artifact/manager.py
@@ -1065,18 +1065,22 @@ class ArtifactManager:
organization_id: str | None,
data: bytes,
primary_key: str = "task_id",
- ) -> None:
+ ) -> str | None:
if not artifact_id or not organization_id:
return None
artifact = await app.DATABASE.artifacts.get_artifact_by_id(artifact_id, organization_id)
if not artifact:
- return
+ return None
# Fire and forget
aio_task = asyncio.create_task(app.STORAGE.store_artifact(artifact, data))
- if not artifact[primary_key]:
+ # A code-block recording artifact is workflow-run-block-scoped rather than task-scoped, so
+ # key the upload tracking on the first available scope id instead of failing on a null task_id.
+ aio_task_key = artifact[primary_key] or artifact["workflow_run_block_id"] or artifact["run_id"]
+ if not aio_task_key:
raise ValueError(f"{primary_key} is required to update artifact data.")
- self.upload_aiotasks_map[artifact[primary_key]].append(aio_task)
+ self.upload_aiotasks_map[aio_task_key].append(aio_task)
+ return aio_task_key
async def retrieve_artifact(self, artifact: Artifact) -> bytes | None:
return await app.STORAGE.retrieve_artifact(artifact)
diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.py
index d928e2a9d..170739e6f 100644
--- a/skyvern/forge/sdk/workflow/models/block.py
+++ b/skyvern/forge/sdk/workflow/models/block.py
@@ -3669,6 +3669,46 @@ async def wrapper({default_args}):
return await user_function()
return await asyncio.wait_for(user_function(), timeout=timeout_seconds)
+ async def _ensure_run_recording_artifact(
+ self,
+ browser_state: BrowserState,
+ workflow_run_id: str,
+ workflow_run_block_id: str,
+ organization_id: str | None,
+ ) -> None:
+ """Register the run-scoped RECORDING row that a code block otherwise lacks.
+
+ The agent path creates it in ``initialize_execution_state``; a code block runs no agent
+ step, so ``_fetch_recording_urls`` finds nothing and the Recording tab is empty. The
+ workflow cleanup's ``persist_video_data`` backfills the finalized video. Best-effort and
+ idempotent across blocks sharing one browser.
+ """
+ browser_artifacts = browser_state.browser_artifacts
+ if not browser_artifacts or all(va.video_artifact_id for va in browser_artifacts.video_artifacts):
+ return
+ try:
+ video_artifacts = await app.BROWSER_MANAGER.get_video_artifacts(
+ workflow_run_id=workflow_run_id, browser_state=browser_state, finalize=False
+ )
+ pending_indexes = [idx for idx, va in enumerate(video_artifacts) if not va.video_artifact_id]
+ if not pending_indexes:
+ return
+ workflow_run_block = await app.DATABASE.observer.get_workflow_run_block(
+ workflow_run_block_id=workflow_run_block_id, organization_id=organization_id
+ )
+ for idx in pending_indexes:
+ video_artifacts[idx].video_artifact_id = await app.ARTIFACT_MANAGER.create_workflow_run_block_artifact(
+ workflow_run_block=workflow_run_block,
+ artifact_type=ArtifactType.RECORDING,
+ data=video_artifacts[idx].video_data,
+ )
+ except Exception:
+ LOG.warning(
+ "Failed to register run-scoped recording artifact for code block",
+ workflow_run_block_id=workflow_run_block_id,
+ exc_info=True,
+ )
+
def get_all_parameters(
self,
workflow_run_id: str,
@@ -3816,6 +3856,13 @@ async def wrapper({default_args}):
organization_id=organization_id,
)
+ await self._ensure_run_recording_artifact(
+ browser_state=browser_state,
+ workflow_run_id=workflow_run_id,
+ workflow_run_block_id=workflow_run_block_id,
+ organization_id=organization_id,
+ )
+
try:
self.format_potential_template_parameters(workflow_run_context)
except Exception as e:
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index c97e189b8..5914202f2 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -6267,12 +6267,18 @@ class WorkflowService:
finalize=close_browser_on_completion,
)
LOG.debug("Persisting video data", number_of_video_artifacts=len(video_artifacts))
+ # Flush here: code-block recordings key on the block/run id, which clean_up_workflow's task-id drain skips.
+ upload_keys: set[str] = set()
for video_artifact in video_artifacts:
- await app.ARTIFACT_MANAGER.update_artifact_data(
+ upload_key = await app.ARTIFACT_MANAGER.update_artifact_data(
artifact_id=video_artifact.video_artifact_id,
organization_id=workflow_run.organization_id,
data=video_artifact.video_data,
)
+ if upload_key:
+ upload_keys.add(upload_key)
+ if upload_keys:
+ await app.ARTIFACT_MANAGER.wait_for_upload_aiotasks(list(upload_keys))
async def persist_har_data(
self,
diff --git a/tests/unit/test_code_block_downloads.py b/tests/unit/test_code_block_downloads.py
index d79f1c129..d78fe13b2 100644
--- a/tests/unit/test_code_block_downloads.py
+++ b/tests/unit/test_code_block_downloads.py
@@ -27,6 +27,7 @@ from skyvern.forge.sdk.workflow.models.parameter import (
WorkflowParameter,
WorkflowParameterType,
)
+from skyvern.webeye.browser_artifacts import BrowserArtifacts
def _output_parameter(key: str) -> OutputParameter:
@@ -77,7 +78,7 @@ def _wire_block_runtime(
values: dict[str, object] | None = None,
) -> None:
page = SimpleNamespace()
- browser_state = SimpleNamespace(get_working_page=AsyncMock(return_value=page))
+ browser_state = SimpleNamespace(get_working_page=AsyncMock(return_value=page), browser_artifacts=BrowserArtifacts())
monkeypatch.setattr(CodeBlock, "get_or_create_browser_state", AsyncMock(return_value=browser_state))
context = SimpleNamespace(
diff --git a/tests/unit/test_code_block_recording_artifact.py b/tests/unit/test_code_block_recording_artifact.py
new file mode 100644
index 000000000..5e2888e92
--- /dev/null
+++ b/tests/unit/test_code_block_recording_artifact.py
@@ -0,0 +1,279 @@
+"""Tests for the run-scoped RECORDING artifact a code block registers for its browser video.
+
+A code block runs no agent step, so the per-step RECORDING row the agent path creates in
+``initialize_execution_state`` never exists and ``_fetch_recording_urls`` finds nothing (the
+Recording tab renders empty). ``CodeBlock._ensure_run_recording_artifact`` closes that gap by
+registering the row up front; the workflow cleanup's ``persist_video_data`` backfills the bytes.
+
+OSS-synced: synthetic ids and example.* placeholders only.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timezone
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from skyvern.forge.sdk.artifact.manager import ArtifactManager
+from skyvern.forge.sdk.artifact.models import Artifact, ArtifactType
+from skyvern.forge.sdk.workflow.models.block import CodeBlock
+from skyvern.forge.sdk.workflow.models.parameter import OutputParameter, ParameterType
+from skyvern.forge.sdk.workflow.service import WorkflowService
+from skyvern.webeye.browser_artifacts import BrowserArtifacts, VideoArtifact
+
+_BLOCK_PATH = "skyvern.forge.sdk.workflow.models.block.app"
+_MANAGER_PATH = "skyvern.forge.sdk.artifact.manager.app"
+_SERVICE_PATH = "skyvern.forge.sdk.workflow.service.app"
+
+
+def _code_block() -> CodeBlock:
+ now = datetime.now(timezone.utc)
+ output_parameter = OutputParameter(
+ parameter_type=ParameterType.OUTPUT,
+ key="recording_output",
+ description="recording test output",
+ output_parameter_id="op_recording",
+ workflow_id="w_recording",
+ created_at=now,
+ modified_at=now,
+ )
+ return CodeBlock(label="record_block", code="value = 'ok'", output_parameter=output_parameter)
+
+
+def _browser_state(video_artifacts: list[VideoArtifact]) -> SimpleNamespace:
+ return SimpleNamespace(browser_artifacts=BrowserArtifacts(video_artifacts=video_artifacts))
+
+
+async def test_registers_run_scoped_recording_when_video_artifact_has_no_id() -> 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)
+ 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)
+ create_artifact = AsyncMock(return_value="a_recording")
+
+ with (
+ patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ 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),
+ ):
+ 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_awaited_once()
+ assert get_video.call_args.kwargs["finalize"] is False
+ assert get_video.call_args.kwargs["workflow_run_id"] == "wr_1"
+ create_artifact.assert_awaited_once()
+ kwargs = create_artifact.call_args.kwargs
+ assert kwargs["artifact_type"] == ArtifactType.RECORDING
+ assert kwargs["data"] == b"partial-video"
+ assert kwargs["workflow_run_block"] is fake_block
+ # The id is stored back so the workflow cleanup updates this exact row.
+ assert video_artifacts[0].video_artifact_id == "a_recording"
+
+
+async def test_is_idempotent_when_video_artifact_already_registered() -> None:
+ video_artifacts = [VideoArtifact(video_path="/tmp/recording.webm", video_artifact_id="a_existing")]
+ browser_state = _browser_state(video_artifacts)
+ get_video = AsyncMock()
+ 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",
+ )
+
+ # Already registered (e.g. by an earlier block sharing the browser) — no file read, no insert.
+ get_video.assert_not_awaited()
+ create_artifact.assert_not_awaited()
+ assert video_artifacts[0].video_artifact_id == "a_existing"
+
+
+async def test_noop_when_no_video_artifacts() -> None:
+ browser_state = _browser_state([])
+ get_video = AsyncMock()
+ 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",
+ )
+
+ get_video.assert_not_awaited()
+ create_artifact.assert_not_awaited()
+
+
+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_block = AsyncMock(
+ return_value=SimpleNamespace(workflow_run_block_id="wrb_1", workflow_run_id="wr_1", organization_id="o_1")
+ )
+ create_artifact = AsyncMock(side_effect=RuntimeError("storage down"))
+
+ with (
+ patch(f"{_BLOCK_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ 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),
+ ):
+ # Recording is best-effort: a failure must never surface to the block outcome.
+ 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",
+ )
+
+ create_artifact.assert_awaited_once()
+ assert video_artifacts[0].video_artifact_id is None
+
+
+def _recording_artifact(
+ *,
+ task_id: str | None = None,
+ workflow_run_block_id: str | None = None,
+ run_id: str | None = None,
+) -> Artifact:
+ now = datetime(2026, 6, 16, tzinfo=timezone.utc)
+ return Artifact(
+ created_at=now,
+ modified_at=now,
+ artifact_id="a_recording",
+ artifact_type=ArtifactType.RECORDING,
+ uri="s3://bucket/recording.webm",
+ organization_id="o_1",
+ task_id=task_id,
+ workflow_run_block_id=workflow_run_block_id,
+ run_id=run_id,
+ )
+
+
+class TestUpdateArtifactDataScopeFallback:
+ """A code-block recording artifact has no task_id, so persist_video_data's update must key the
+ upload on another scope id instead of raising (which would break workflow cleanup)."""
+
+ @pytest.mark.asyncio
+ async def test_keys_upload_by_block_id_when_task_id_absent(self) -> None:
+ manager = ArtifactManager()
+ artifact = _recording_artifact(workflow_run_block_id="wrb_1", run_id="wr_1")
+ with (
+ patch(f"{_MANAGER_PATH}.DATABASE.artifacts.get_artifact_by_id", AsyncMock(return_value=artifact)),
+ patch(f"{_MANAGER_PATH}.STORAGE.store_artifact", AsyncMock()),
+ ):
+ await manager.update_artifact_data(artifact_id="a_recording", organization_id="o_1", data=b"video")
+ await asyncio.gather(*manager.upload_aiotasks_map["wrb_1"])
+
+ assert list(manager.upload_aiotasks_map.keys()) == ["wrb_1"]
+
+ @pytest.mark.asyncio
+ async def test_prefers_task_id_when_present(self) -> None:
+ manager = ArtifactManager()
+ artifact = _recording_artifact(task_id="tsk_1", workflow_run_block_id="wrb_1")
+ with (
+ patch(f"{_MANAGER_PATH}.DATABASE.artifacts.get_artifact_by_id", AsyncMock(return_value=artifact)),
+ patch(f"{_MANAGER_PATH}.STORAGE.store_artifact", AsyncMock()),
+ ):
+ await manager.update_artifact_data(artifact_id="a_recording", organization_id="o_1", data=b"video")
+ await asyncio.gather(*manager.upload_aiotasks_map["tsk_1"])
+
+ assert "tsk_1" in manager.upload_aiotasks_map
+ assert "wrb_1" not in manager.upload_aiotasks_map
+
+ @pytest.mark.asyncio
+ async def test_raises_when_no_scope_id_available(self) -> None:
+ manager = ArtifactManager()
+ artifact = _recording_artifact()
+ with (
+ patch(f"{_MANAGER_PATH}.DATABASE.artifacts.get_artifact_by_id", AsyncMock(return_value=artifact)),
+ patch(f"{_MANAGER_PATH}.STORAGE.store_artifact", AsyncMock()),
+ ):
+ with pytest.raises(ValueError):
+ await manager.update_artifact_data(artifact_id="a_recording", organization_id="o_1", data=b"video")
+
+ @pytest.mark.asyncio
+ async def test_returns_scope_key_so_callers_can_drain(self) -> None:
+ manager = ArtifactManager()
+ artifact = _recording_artifact(workflow_run_block_id="wrb_1", run_id="wr_1")
+ with (
+ patch(f"{_MANAGER_PATH}.DATABASE.artifacts.get_artifact_by_id", AsyncMock(return_value=artifact)),
+ patch(f"{_MANAGER_PATH}.STORAGE.store_artifact", AsyncMock()),
+ ):
+ key = await manager.update_artifact_data(artifact_id="a_recording", organization_id="o_1", data=b"video")
+ await asyncio.gather(*manager.upload_aiotasks_map["wrb_1"])
+
+ assert key == "wrb_1"
+
+ @pytest.mark.asyncio
+ async def test_returns_none_when_artifact_missing(self) -> None:
+ manager = ArtifactManager()
+ with patch(f"{_MANAGER_PATH}.DATABASE.artifacts.get_artifact_by_id", AsyncMock(return_value=None)):
+ key = await manager.update_artifact_data(artifact_id="a_missing", organization_id="o_1", data=b"video")
+
+ assert key is None
+
+
+class TestPersistVideoDataFlushesUploads:
+ """The finalized recording upload is keyed on workflow_run_block_id/run_id for a code block, which
+ clean_up_workflow's task-id drain never awaits — persist_video_data must flush those keys itself."""
+
+ @pytest.mark.asyncio
+ async def test_flushes_the_keys_it_enqueued(self) -> None:
+ video_artifacts = [
+ VideoArtifact(video_path="/tmp/recording.webm", video_artifact_id="a_recording", video_data=b"video")
+ ]
+ get_video = AsyncMock(return_value=video_artifacts)
+ update_data = AsyncMock(return_value="wrb_1")
+ wait_for_uploads = AsyncMock()
+ workflow = SimpleNamespace(workflow_id="w_1")
+ workflow_run = SimpleNamespace(workflow_run_id="wr_1", organization_id="o_1")
+
+ with (
+ patch(f"{_SERVICE_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_SERVICE_PATH}.ARTIFACT_MANAGER.update_artifact_data", update_data),
+ patch(f"{_SERVICE_PATH}.ARTIFACT_MANAGER.wait_for_upload_aiotasks", wait_for_uploads),
+ ):
+ await WorkflowService().persist_video_data(_browser_state(video_artifacts), workflow, workflow_run)
+
+ update_data.assert_awaited_once()
+ wait_for_uploads.assert_awaited_once_with(["wrb_1"])
+
+ @pytest.mark.asyncio
+ async def test_skips_drain_when_nothing_enqueued(self) -> None:
+ get_video = AsyncMock(return_value=[])
+ update_data = AsyncMock(return_value=None)
+ wait_for_uploads = AsyncMock()
+ workflow = SimpleNamespace(workflow_id="w_1")
+ workflow_run = SimpleNamespace(workflow_run_id="wr_1", organization_id="o_1")
+
+ with (
+ patch(f"{_SERVICE_PATH}.BROWSER_MANAGER.get_video_artifacts", get_video),
+ patch(f"{_SERVICE_PATH}.ARTIFACT_MANAGER.update_artifact_data", update_data),
+ patch(f"{_SERVICE_PATH}.ARTIFACT_MANAGER.wait_for_upload_aiotasks", wait_for_uploads),
+ ):
+ await WorkflowService().persist_video_data(_browser_state([]), workflow, workflow_run)
+
+ wait_for_uploads.assert_not_awaited()
diff --git a/tests/unit/test_code_block_sandbox.py b/tests/unit/test_code_block_sandbox.py
index 9305dcc5c..d12465cf0 100644
--- a/tests/unit/test_code_block_sandbox.py
+++ b/tests/unit/test_code_block_sandbox.py
@@ -18,6 +18,7 @@ from skyvern.forge.sdk.workflow.exceptions import InsecureCodeDetected
from skyvern.forge.sdk.workflow.models.block import CodeBlock
from skyvern.forge.sdk.workflow.models.parameter import OutputParameter, ParameterType
from skyvern.schemas.workflows import BlockStatus
+from skyvern.webeye.browser_artifacts import BrowserArtifacts
# ---------------------------------------------------------------------------
# is_safe_code — rejection tests
@@ -679,6 +680,9 @@ async def wrapper({default_args}):
@pytest.mark.asyncio
async def test_execute_uses_configured_code_block_timeout(self, monkeypatch: pytest.MonkeyPatch) -> None:
class FakeBrowserState:
+ def __init__(self) -> None:
+ self.browser_artifacts = BrowserArtifacts()
+
async def get_working_page(self) -> object:
return object()
@@ -957,6 +961,9 @@ async def _run_credential_code_block(monkeypatch: "pytest.MonkeyPatch", wrc, cod
)
class FakeBrowserState:
+ def __init__(self) -> None:
+ self.browser_artifacts = BrowserArtifacts()
+
async def get_working_page(self) -> object:
return MagicMock()
diff --git a/tests/unit/workflow/test_code_block_recorder.py b/tests/unit/workflow/test_code_block_recorder.py
index 1102de988..99f91e3fc 100644
--- a/tests/unit/workflow/test_code_block_recorder.py
+++ b/tests/unit/workflow/test_code_block_recorder.py
@@ -25,6 +25,7 @@ from skyvern.forge.sdk.workflow.models.parameter import OutputParameter, Paramet
from skyvern.schemas.workflows import BlockStatus
from skyvern.webeye.actions.action_types import ActionType
from skyvern.webeye.actions.actions import Action, ActionStatus
+from skyvern.webeye.browser_artifacts import BrowserArtifacts
class FakeLocator:
@@ -309,6 +310,9 @@ def _patch_execute_environment(
context: FakeWorkflowRunContext,
) -> dict[str, AsyncMock]:
class FakeBrowserState:
+ def __init__(self) -> None:
+ self.browser_artifacts = BrowserArtifacts()
+
async def get_working_page(self): # noqa: ANN201
return page