Skip to content

Automate browser based workflows with AI

feat: support artifact bundling for cached script execution (#5247)

pedrohsdb0b1726b1f6a8
diff --git a/skyvern/core/script_generations/script_skyvern_page.py b/skyvern/core/script_generations/script_skyvern_page.py
index a3ba4732e..2910280d6 100644
--- a/skyvern/core/script_generations/script_skyvern_page.py
+++ b/skyvern/core/script_generations/script_skyvern_page.py
@@ -532,7 +532,6 @@ class ScriptSkyvernPage(SkyvernPage):
screenshot = await browser_state.take_post_action_screenshot(scrolling_number=0)
if screenshot:
- # Create a minimal Step object for artifact creation
step = await app.DATABASE.get_step(
context.step_id,
organization_id=context.organization_id,
@@ -540,15 +539,29 @@ class ScriptSkyvernPage(SkyvernPage):
if not step:
return
- await app.ARTIFACT_MANAGER.create_artifact(
- step=step,
- artifact_type=ArtifactType.SCREENSHOT_ACTION,
- data=screenshot,
- )
+ if context.use_artifact_bundling:
+ app.ARTIFACT_MANAGER.accumulate_screenshot_to_step_archive(
+ step=step,
+ screenshots=[screenshot],
+ artifact_type=ArtifactType.SCREENSHOT_ACTION,
+ workflow_run_id=context.workflow_run_id,
+ workflow_run_block_id=context.workflow_run_block_id,
+ run_id=context.run_id,
+ )
+ else:
+ await app.ARTIFACT_MANAGER.create_artifact(
+ step=step,
+ artifact_type=ArtifactType.SCREENSHOT_ACTION,
+ data=screenshot,
+ )
except Exception:
- # If screenshot creation fails, don't block execution
- pass
+ ctx = skyvern_context.current()
+ LOG.warning(
+ "Failed to create screenshot after action",
+ step_id=ctx.step_id if ctx else None,
+ exc_info=True,
+ )
@classmethod
async def _create_html_action_after_execution(cls) -> None:
@@ -582,11 +595,21 @@ class ScriptSkyvernPage(SkyvernPage):
if not step:
return
- await app.ARTIFACT_MANAGER.create_artifact(
- step=step,
- artifact_type=ArtifactType.HTML_ACTION,
- data=html.encode("utf-8"),
- )
+ html_bytes = html.encode("utf-8")
+ if context.use_artifact_bundling:
+ app.ARTIFACT_MANAGER.accumulate_action_html_to_archive(
+ step=step,
+ html_action=html_bytes,
+ workflow_run_id=context.workflow_run_id,
+ workflow_run_block_id=context.workflow_run_block_id,
+ run_id=context.run_id,
+ )
+ else:
+ await app.ARTIFACT_MANAGER.create_artifact(
+ step=step,
+ artifact_type=ArtifactType.HTML_ACTION,
+ data=html_bytes,
+ )
except Exception:
LOG.warning("Failed to create HTML artifact after action", exc_info=True)
@@ -620,11 +643,21 @@ class ScriptSkyvernPage(SkyvernPage):
if not step:
return
- await app.ARTIFACT_MANAGER.create_artifact(
- step=step,
- artifact_type=ArtifactType.SCREENSHOT_FINAL,
- data=screenshot,
- )
+ if context.use_artifact_bundling:
+ app.ARTIFACT_MANAGER.accumulate_screenshot_to_step_archive(
+ step=step,
+ screenshots=[screenshot],
+ artifact_type=ArtifactType.SCREENSHOT_FINAL,
+ workflow_run_id=context.workflow_run_id,
+ workflow_run_block_id=context.workflow_run_block_id,
+ run_id=context.run_id,
+ )
+ else:
+ await app.ARTIFACT_MANAGER.create_artifact(
+ step=step,
+ artifact_type=ArtifactType.SCREENSHOT_FINAL,
+ data=screenshot,
+ )
except Exception:
LOG.warning("Failed to create final screenshot", exc_info=True)
diff --git a/skyvern/forge/sdk/artifact/manager.py b/skyvern/forge/sdk/artifact/manager.py
index 87d50a05d..7c8ef729b 100644
--- a/skyvern/forge/sdk/artifact/manager.py
+++ b/skyvern/forge/sdk/artifact/manager.py
@@ -23,6 +23,12 @@ from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock
LOG = structlog.get_logger(__name__)
+_SCREENSHOT_PREFIX_MAP: dict[ArtifactType, str] = {
+ ArtifactType.SCREENSHOT_LLM: "screenshot_llm",
+ ArtifactType.SCREENSHOT_ACTION: "screenshot_action",
+ ArtifactType.SCREENSHOT_FINAL: "screenshot_final",
+}
+
@dataclass
class ArtifactBatchData:
@@ -930,6 +936,7 @@ class ArtifactManager:
step=step,
workflow_run_id=workflow_run_id or (context.workflow_run_id if context else None),
workflow_run_block_id=workflow_run_block_id
+ or (context.workflow_run_block_id if context else None)
or (context.parent_workflow_run_block_id if context else None),
run_id=run_id or (context.run_id if context else None),
)
@@ -1052,7 +1059,7 @@ class ArtifactManager:
(e.g. action.screenshot_artifact_id) before the archive is flushed.
"""
acc = self._get_or_create_step_archive(step, workflow_run_id, workflow_run_block_id, run_id)
- prefix = "screenshot_llm" if artifact_type == ArtifactType.SCREENSHOT_LLM else "screenshot_action"
+ prefix = _SCREENSHOT_PREFIX_MAP.get(artifact_type, "screenshot_action")
artifact_ids: list[str] = []
for screenshot_bytes in screenshots:
idx = sum(1 for k in acc.entries if k.startswith(f"{prefix}_"))
diff --git a/skyvern/forge/sdk/core/skyvern_context.py b/skyvern/forge/sdk/core/skyvern_context.py
index 39dcd5b13..e2cd8a82f 100644
--- a/skyvern/forge/sdk/core/skyvern_context.py
+++ b/skyvern/forge/sdk/core/skyvern_context.py
@@ -50,6 +50,7 @@ class SkyvernContext:
action_order: int = 0
prompt: str | None = None
parent_workflow_run_block_id: str | None = None
+ workflow_run_block_id: str | None = None
loop_metadata: dict[str, Any] | None = None
loop_internal_state: dict[str, Any] | None = None
loop_output_values: list[dict[str, Any]] | None = None
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index d320995b9..29da2c9c7 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -678,6 +678,26 @@ class WorkflowService:
)
)
+ # Check artifact bundling flag at workflow level so it applies to both agent and cached paths.
+ # See also: skyvern/forge/agent.py Agent.agent_step() checks per-task for standalone task runs.
+ new_context = skyvern_context.current()
+ if new_context:
+ try:
+ new_context.use_artifact_bundling = await app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached(
+ "USE_ARTIFACT_BUNDLING",
+ workflow_run.workflow_run_id,
+ properties={"organization_id": organization.organization_id},
+ )
+ LOG.debug(
+ "USE_ARTIFACT_BUNDLING flag resolved for workflow",
+ use_artifact_bundling=new_context.use_artifact_bundling,
+ workflow_run_id=workflow_run.workflow_run_id,
+ organization_id=organization.organization_id,
+ )
+ except Exception:
+ LOG.warning("Failed to check USE_ARTIFACT_BUNDLING flag for workflow", exc_info=True)
+ new_context.use_artifact_bundling = False
+
# Create all the workflow run parameters, AWSSecretParameter won't have workflow run parameters created.
all_workflow_parameters = await self.get_workflow_parameters(workflow_id=workflow.workflow_id)
try:
diff --git a/skyvern/services/script_service.py b/skyvern/services/script_service.py
index 3da4046c3..1e7019a13 100644
--- a/skyvern/services/script_service.py
+++ b/skyvern/services/script_service.py
@@ -520,6 +520,9 @@ async def _create_workflow_block_run_and_task(
context.step_id = step_id
context.task_id = task_id
+ # Set for archive accumulator DB rows. Overwritten at the start of each block,
+ # so no explicit clear is needed between sequential blocks.
+ context.workflow_run_block_id = workflow_run_block_id
return workflow_run_block_id, task_id, step_id
@@ -619,6 +622,17 @@ async def _update_workflow_block(
context = skyvern_context.current()
if not context or not context.organization_id or not context.workflow_run_id or not context.workflow_id:
return
+
+ # Flush accumulated step artifacts into a single ZIP before finalizing the step.
+ # This mirrors the agent path (agent.py flush_step_archive at step completion).
+ # Known limitation: if flush fails (e.g. S3 timeout), accumulated artifacts for
+ # this step are lost. This matches the agent path's behavior.
+ if context.use_artifact_bundling and step_id:
+ try:
+ await app.ARTIFACT_MANAGER.flush_step_archive(step_id)
+ except Exception:
+ LOG.warning("Failed to flush step archive for cached block", step_id=step_id, exc_info=True)
+
final_output = output
if task_id:
if step_id:
diff --git a/tests/unit/test_cached_artifact_bundling.py b/tests/unit/test_cached_artifact_bundling.py
new file mode 100644
index 000000000..effc9d468
--- /dev/null
+++ b/tests/unit/test_cached_artifact_bundling.py
@@ -0,0 +1,450 @@
+"""Unit tests for artifact bundling in the cached script execution path.
+
+Tests that ScriptSkyvernPage artifact methods route to accumulate_* when
+use_artifact_bundling is True, and to create_artifact() when False.
+Also tests the flush in _update_workflow_block().
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from skyvern.core.script_generations.script_skyvern_page import ScriptSkyvernPage
+from skyvern.forge.sdk.artifact.manager import ArtifactManager
+from skyvern.forge.sdk.artifact.models import ArtifactType
+from skyvern.forge.sdk.artifact.storage.test_helpers import TEST_ORGANIZATION_ID, TEST_TASK_ID, create_fake_step
+from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
+from skyvern.services.script_service import _update_workflow_block
+
+TEST_STEP_ID = "step_cached_bundle_001"
+TEST_WORKFLOW_RUN_ID = "wr_test_cached_001"
+TEST_WORKFLOW_RUN_BLOCK_ID = "wrb_test_cached_001"
+TEST_RUN_ID = "run_test_cached_001"
+
+
+# ---------------------------------------------------------------------------
+# accumulate_screenshot_to_step_archive: SCREENSHOT_FINAL prefix
+# ---------------------------------------------------------------------------
+
+
+class TestScreenshotFinalPrefix:
+ """SCREENSHOT_FINAL should get its own prefix in the step archive."""
+
+ def test_final_screenshots_use_screenshot_final_prefix(self) -> None:
+ manager = ArtifactManager()
+ step = create_fake_step(TEST_STEP_ID)
+ ids = manager.accumulate_screenshot_to_step_archive(
+ step=step, screenshots=[b"png_final"], artifact_type=ArtifactType.SCREENSHOT_FINAL
+ )
+ acc = manager._step_archives[step.step_id]
+ assert "screenshot_final_0.png" in acc.entries
+ assert acc.entries["screenshot_final_0.png"] == b"png_final"
+ assert len(ids) == 1
+
+ def test_final_and_action_screenshots_have_separate_indices(self) -> None:
+ """SCREENSHOT_FINAL and SCREENSHOT_ACTION should not share index counters."""
+ manager = ArtifactManager()
+ step = create_fake_step(TEST_STEP_ID)
+ manager.accumulate_screenshot_to_step_archive(
+ step=step, screenshots=[b"action_png"], artifact_type=ArtifactType.SCREENSHOT_ACTION
+ )
+ manager.accumulate_screenshot_to_step_archive(
+ step=step, screenshots=[b"final_png"], artifact_type=ArtifactType.SCREENSHOT_FINAL
+ )
+ acc = manager._step_archives[step.step_id]
+ assert "screenshot_action_0.png" in acc.entries
+ assert "screenshot_final_0.png" in acc.entries
+ assert len(acc.entries) == 2
+
+
+# ---------------------------------------------------------------------------
+# ScriptSkyvernPage bundling branch tests
+# ---------------------------------------------------------------------------
+
+
+TEST_WORKFLOW_ID = "wf_test_cached_001"
+
+
+def _make_context(use_bundling: bool) -> SkyvernContext:
+ return SkyvernContext(
+ organization_id=TEST_ORGANIZATION_ID,
+ task_id=TEST_TASK_ID,
+ step_id=TEST_STEP_ID,
+ workflow_id=TEST_WORKFLOW_ID,
+ workflow_run_id=TEST_WORKFLOW_RUN_ID,
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ run_id=TEST_RUN_ID,
+ use_artifact_bundling=use_bundling,
+ )
+
+
+class TestScreenshotAfterExecutionBundling:
+ """_create_screenshot_after_execution routes to accumulate or create_artifact."""
+
+ @pytest.mark.asyncio
+ async def test_bundling_enabled_uses_accumulate(self) -> None:
+ context = _make_context(use_bundling=True)
+ step = create_fake_step(TEST_STEP_ID)
+ mock_browser_state = MagicMock()
+ mock_browser_state.take_post_action_screenshot = AsyncMock(return_value=b"screenshot_data")
+
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.accumulate_screenshot_to_step_archive = MagicMock(return_value=["aid_1"])
+ mock_manager.create_artifact = AsyncMock()
+
+ with (
+ patch("skyvern.core.script_generations.script_skyvern_page.skyvern_context") as mock_ctx,
+ patch("skyvern.core.script_generations.script_skyvern_page.app") as mock_app,
+ patch.object(ScriptSkyvernPage, "_get_browser_state", new_callable=AsyncMock) as mock_get_bs,
+ ):
+ mock_ctx.ensure_context.return_value = context
+ mock_get_bs.return_value = mock_browser_state
+ mock_app.DATABASE.get_step = AsyncMock(return_value=step)
+ mock_app.ARTIFACT_MANAGER = mock_manager
+
+ await ScriptSkyvernPage._create_screenshot_after_execution()
+
+ mock_manager.accumulate_screenshot_to_step_archive.assert_called_once_with(
+ step=step,
+ screenshots=[b"screenshot_data"],
+ artifact_type=ArtifactType.SCREENSHOT_ACTION,
+ workflow_run_id=TEST_WORKFLOW_RUN_ID,
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ run_id=TEST_RUN_ID,
+ )
+ mock_manager.create_artifact.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_bundling_disabled_uses_create_artifact(self) -> None:
+ context = _make_context(use_bundling=False)
+ step = create_fake_step(TEST_STEP_ID)
+ mock_browser_state = MagicMock()
+ mock_browser_state.take_post_action_screenshot = AsyncMock(return_value=b"screenshot_data")
+
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.accumulate_screenshot_to_step_archive = MagicMock()
+ mock_manager.create_artifact = AsyncMock(return_value="aid_1")
+
+ with (
+ patch("skyvern.core.script_generations.script_skyvern_page.skyvern_context") as mock_ctx,
+ patch("skyvern.core.script_generations.script_skyvern_page.app") as mock_app,
+ patch.object(ScriptSkyvernPage, "_get_browser_state", new_callable=AsyncMock) as mock_get_bs,
+ ):
+ mock_ctx.ensure_context.return_value = context
+ mock_get_bs.return_value = mock_browser_state
+ mock_app.DATABASE.get_step = AsyncMock(return_value=step)
+ mock_app.ARTIFACT_MANAGER = mock_manager
+
+ await ScriptSkyvernPage._create_screenshot_after_execution()
+
+ mock_manager.create_artifact.assert_called_once_with(
+ step=step,
+ artifact_type=ArtifactType.SCREENSHOT_ACTION,
+ data=b"screenshot_data",
+ )
+ mock_manager.accumulate_screenshot_to_step_archive.assert_not_called()
+
+
+class TestHtmlActionAfterExecutionBundling:
+ """_create_html_action_after_execution routes to accumulate or create_artifact."""
+
+ @pytest.mark.asyncio
+ async def test_bundling_enabled_uses_accumulate(self) -> None:
+ context = _make_context(use_bundling=True)
+ step = create_fake_step(TEST_STEP_ID)
+ html_content = "<html><body>test</body></html>"
+
+ mock_browser_state = MagicMock()
+ mock_working_page = AsyncMock()
+ mock_browser_state.get_working_page = AsyncMock(return_value=mock_working_page)
+
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.accumulate_action_html_to_archive = MagicMock()
+ mock_manager.create_artifact = AsyncMock()
+
+ with (
+ patch("skyvern.core.script_generations.script_skyvern_page.skyvern_context") as mock_ctx,
+ patch("skyvern.core.script_generations.script_skyvern_page.app") as mock_app,
+ patch.object(ScriptSkyvernPage, "_get_browser_state", new_callable=AsyncMock) as mock_get_bs,
+ patch("skyvern.core.script_generations.script_skyvern_page.SkyvernFrame") as mock_frame_cls,
+ ):
+ mock_ctx.ensure_context.return_value = context
+ mock_get_bs.return_value = mock_browser_state
+ mock_app.DATABASE.get_step = AsyncMock(return_value=step)
+ mock_app.ARTIFACT_MANAGER = mock_manager
+
+ mock_frame = MagicMock()
+ mock_frame.get_content = AsyncMock(return_value=html_content)
+ mock_frame_cls.create_instance = AsyncMock(return_value=mock_frame)
+
+ await ScriptSkyvernPage._create_html_action_after_execution()
+
+ mock_manager.accumulate_action_html_to_archive.assert_called_once_with(
+ step=step,
+ html_action=html_content.encode("utf-8"),
+ workflow_run_id=TEST_WORKFLOW_RUN_ID,
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ run_id=TEST_RUN_ID,
+ )
+ mock_manager.create_artifact.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_bundling_disabled_uses_create_artifact(self) -> None:
+ context = _make_context(use_bundling=False)
+ step = create_fake_step(TEST_STEP_ID)
+ html_content = "<html><body>test</body></html>"
+
+ mock_browser_state = MagicMock()
+ mock_working_page = AsyncMock()
+ mock_browser_state.get_working_page = AsyncMock(return_value=mock_working_page)
+
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.accumulate_action_html_to_archive = MagicMock()
+ mock_manager.create_artifact = AsyncMock(return_value="aid_1")
+
+ with (
+ patch("skyvern.core.script_generations.script_skyvern_page.skyvern_context") as mock_ctx,
+ patch("skyvern.core.script_generations.script_skyvern_page.app") as mock_app,
+ patch.object(ScriptSkyvernPage, "_get_browser_state", new_callable=AsyncMock) as mock_get_bs,
+ patch("skyvern.core.script_generations.script_skyvern_page.SkyvernFrame") as mock_frame_cls,
+ ):
+ mock_ctx.ensure_context.return_value = context
+ mock_get_bs.return_value = mock_browser_state
+ mock_app.DATABASE.get_step = AsyncMock(return_value=step)
+ mock_app.ARTIFACT_MANAGER = mock_manager
+
+ mock_frame = MagicMock()
+ mock_frame.get_content = AsyncMock(return_value=html_content)
+ mock_frame_cls.create_instance = AsyncMock(return_value=mock_frame)
+
+ await ScriptSkyvernPage._create_html_action_after_execution()
+
+ mock_manager.create_artifact.assert_called_once_with(
+ step=step,
+ artifact_type=ArtifactType.HTML_ACTION,
+ data=html_content.encode("utf-8"),
+ )
+ mock_manager.accumulate_action_html_to_archive.assert_not_called()
+
+
+class TestFinalScreenshotBundling:
+ """_create_final_screenshot routes to accumulate or create_artifact."""
+
+ @pytest.mark.asyncio
+ async def test_bundling_enabled_uses_accumulate(self) -> None:
+ context = _make_context(use_bundling=True)
+ step = create_fake_step(TEST_STEP_ID)
+ mock_browser_state = MagicMock()
+ mock_browser_state.get_working_page = AsyncMock(return_value=MagicMock())
+ mock_browser_state.take_fullpage_screenshot = AsyncMock(return_value=b"fullpage_png")
+
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.accumulate_screenshot_to_step_archive = MagicMock(return_value=["aid_final"])
+ mock_manager.create_artifact = AsyncMock()
+
+ with (
+ patch("skyvern.core.script_generations.script_skyvern_page.skyvern_context") as mock_ctx,
+ patch("skyvern.core.script_generations.script_skyvern_page.app") as mock_app,
+ patch.object(ScriptSkyvernPage, "_get_browser_state", new_callable=AsyncMock) as mock_get_bs,
+ ):
+ mock_ctx.ensure_context.return_value = context
+ mock_get_bs.return_value = mock_browser_state
+ mock_app.DATABASE.get_step = AsyncMock(return_value=step)
+ mock_app.ARTIFACT_MANAGER = mock_manager
+
+ await ScriptSkyvernPage._create_final_screenshot()
+
+ mock_manager.accumulate_screenshot_to_step_archive.assert_called_once_with(
+ step=step,
+ screenshots=[b"fullpage_png"],
+ artifact_type=ArtifactType.SCREENSHOT_FINAL,
+ workflow_run_id=TEST_WORKFLOW_RUN_ID,
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ run_id=TEST_RUN_ID,
+ )
+ mock_manager.create_artifact.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_bundling_disabled_uses_create_artifact(self) -> None:
+ context = _make_context(use_bundling=False)
+ step = create_fake_step(TEST_STEP_ID)
+ mock_browser_state = MagicMock()
+ mock_browser_state.get_working_page = AsyncMock(return_value=MagicMock())
+ mock_browser_state.take_fullpage_screenshot = AsyncMock(return_value=b"fullpage_png")
+
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.accumulate_screenshot_to_step_archive = MagicMock()
+ mock_manager.create_artifact = AsyncMock(return_value="aid_final")
+
+ with (
+ patch("skyvern.core.script_generations.script_skyvern_page.skyvern_context") as mock_ctx,
+ patch("skyvern.core.script_generations.script_skyvern_page.app") as mock_app,
+ patch.object(ScriptSkyvernPage, "_get_browser_state", new_callable=AsyncMock) as mock_get_bs,
+ ):
+ mock_ctx.ensure_context.return_value = context
+ mock_get_bs.return_value = mock_browser_state
+ mock_app.DATABASE.get_step = AsyncMock(return_value=step)
+ mock_app.ARTIFACT_MANAGER = mock_manager
+
+ await ScriptSkyvernPage._create_final_screenshot()
+
+ mock_manager.create_artifact.assert_called_once_with(
+ step=step,
+ artifact_type=ArtifactType.SCREENSHOT_FINAL,
+ data=b"fullpage_png",
+ )
+ mock_manager.accumulate_screenshot_to_step_archive.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# _update_workflow_block flush tests
+# ---------------------------------------------------------------------------
+
+
+class TestUpdateWorkflowBlockFlush:
+ """_update_workflow_block flushes step archive when bundling is enabled."""
+
+ @pytest.mark.asyncio
+ async def test_flush_called_when_bundling_enabled(self) -> None:
+ context = _make_context(use_bundling=True)
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.flush_step_archive = AsyncMock()
+
+ with (
+ patch("skyvern.services.script_service.skyvern_context") as mock_ctx,
+ patch("skyvern.services.script_service.app") as mock_app,
+ patch("skyvern.services.script_service.script_run_context_manager") as mock_run_ctx,
+ ):
+ mock_ctx.current.return_value = context
+ mock_app.ARTIFACT_MANAGER = mock_manager
+ mock_app.DATABASE.update_step = AsyncMock()
+ mock_app.DATABASE.update_task = AsyncMock(return_value=MagicMock(extracted_information=None))
+ mock_app.DATABASE.update_workflow_run_block = AsyncMock()
+ mock_app.STORAGE.get_downloaded_files = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.get_recent_task_screenshot_artifacts = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.get_recent_workflow_screenshot_artifacts = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.send_workflow_response = AsyncMock()
+ mock_run_ctx.get_run_context.return_value = None
+
+ await _update_workflow_block(
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ status=MagicMock(value="completed"),
+ task_id=TEST_TASK_ID,
+ step_id=TEST_STEP_ID,
+ )
+
+ mock_manager.flush_step_archive.assert_awaited_once_with(TEST_STEP_ID)
+
+ @pytest.mark.asyncio
+ async def test_flush_not_called_when_bundling_disabled(self) -> None:
+ context = _make_context(use_bundling=False)
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.flush_step_archive = AsyncMock()
+
+ with (
+ patch("skyvern.services.script_service.skyvern_context") as mock_ctx,
+ patch("skyvern.services.script_service.app") as mock_app,
+ patch("skyvern.services.script_service.script_run_context_manager") as mock_run_ctx,
+ ):
+ mock_ctx.current.return_value = context
+ mock_app.ARTIFACT_MANAGER = mock_manager
+ mock_app.DATABASE.update_step = AsyncMock()
+ mock_app.DATABASE.update_task = AsyncMock(return_value=MagicMock(extracted_information=None))
+ mock_app.DATABASE.update_workflow_run_block = AsyncMock()
+ mock_app.STORAGE.get_downloaded_files = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.get_recent_task_screenshot_artifacts = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.get_recent_workflow_screenshot_artifacts = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.send_workflow_response = AsyncMock()
+ mock_run_ctx.get_run_context.return_value = None
+
+ await _update_workflow_block(
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ status=MagicMock(value="completed"),
+ task_id=TEST_TASK_ID,
+ step_id=TEST_STEP_ID,
+ )
+
+ mock_manager.flush_step_archive.assert_not_awaited()
+
+ @pytest.mark.asyncio
+ async def test_flush_not_called_without_step_id(self) -> None:
+ context = _make_context(use_bundling=True)
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.flush_step_archive = AsyncMock()
+
+ with (
+ patch("skyvern.services.script_service.skyvern_context") as mock_ctx,
+ patch("skyvern.services.script_service.app") as mock_app,
+ patch("skyvern.services.script_service.script_run_context_manager") as mock_run_ctx,
+ ):
+ mock_ctx.current.return_value = context
+ mock_app.ARTIFACT_MANAGER = mock_manager
+ mock_app.DATABASE.update_workflow_run_block = AsyncMock()
+ mock_app.WORKFLOW_SERVICE.send_workflow_response = AsyncMock()
+ mock_run_ctx.get_run_context.return_value = None
+
+ await _update_workflow_block(
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ status=MagicMock(value="completed"),
+ task_id=None,
+ step_id=None,
+ )
+
+ mock_manager.flush_step_archive.assert_not_awaited()
+
+ @pytest.mark.asyncio
+ async def test_flush_failure_does_not_block_step_finalization(self) -> None:
+ """If flush_step_archive raises, _update_workflow_block should still proceed."""
+
+ context = _make_context(use_bundling=True)
+ mock_manager = MagicMock(spec=ArtifactManager)
+ mock_manager.flush_step_archive = AsyncMock(side_effect=RuntimeError("S3 timeout"))
+
+ with (
+ patch("skyvern.services.script_service.skyvern_context") as mock_ctx,
+ patch("skyvern.services.script_service.app") as mock_app,
+ patch("skyvern.services.script_service.script_run_context_manager") as mock_run_ctx,
+ ):
+ mock_ctx.current.return_value = context
+ mock_app.ARTIFACT_MANAGER = mock_manager
+ mock_app.DATABASE.update_step = AsyncMock()
+ mock_app.DATABASE.update_task = AsyncMock(return_value=MagicMock(extracted_information=None))
+ mock_app.DATABASE.update_workflow_run_block = AsyncMock()
+ mock_app.STORAGE.get_downloaded_files = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.get_recent_task_screenshot_artifacts = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.get_recent_workflow_screenshot_artifacts = AsyncMock(return_value=[])
+ mock_app.WORKFLOW_SERVICE.send_workflow_response = AsyncMock()
+ mock_run_ctx.get_run_context.return_value = None
+
+ # Should NOT raise despite flush failure
+ await _update_workflow_block(
+ workflow_run_block_id=TEST_WORKFLOW_RUN_BLOCK_ID,
+ status=MagicMock(value="completed"),
+ task_id=TEST_TASK_ID,
+ step_id=TEST_STEP_ID,
+ )
+
+ # Flush was attempted
+ mock_manager.flush_step_archive.assert_awaited_once_with(TEST_STEP_ID)
+
+
+# ---------------------------------------------------------------------------
+# workflow_run_block_id context propagation
+# ---------------------------------------------------------------------------
+
+
+class TestWorkflowRunBlockIdContext:
+ """SkyvernContext.workflow_run_block_id field exists and defaults correctly."""
+
+ def test_default_is_none(self) -> None:
+ ctx = SkyvernContext()
+ assert ctx.workflow_run_block_id is None
+
+ def test_can_be_set(self) -> None:
+ ctx = SkyvernContext(workflow_run_block_id="wrb_123")
+ assert ctx.workflow_run_block_id == "wrb_123"
+
+ def test_set_after_creation(self) -> None:
+ ctx = SkyvernContext()
+ ctx.workflow_run_block_id = "wrb_456"
+ assert ctx.workflow_run_block_id == "wrb_456"