Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 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 creationstep = 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,+ )@classmethodasync 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.pyindex 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 WorkflowRunBlockLOG = 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",+}+@dataclassclass 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.pyindex 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 = 0prompt: str | None = Noneparent_workflow_run_block_id: str | None = None+ workflow_run_block_id: str | None = Noneloop_metadata: dict[str, Any] | None = Noneloop_internal_state: dict[str, Any] | None = Noneloop_output_values: list[dict[str, Any]] | None = Nonediff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex 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.pyindex 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_idcontext.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_idreturn 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 = outputif task_id:if step_id:diff --git a/tests/unit/test_cached_artifact_bundling.py b/tests/unit/test_cached_artifact_bundling.pynew file mode 100644index 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"