Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
feat: add Workflow Trigger Block backend (#SKY-8072) (#4885)
Celal Zamanoğlu8fbf937ea49c
diff --git a/skyvern/cli/mcp_tools/blocks.py b/skyvern/cli/mcp_tools/blocks.pyindex 3d610ffbb..c0f0f4af8 100644--- a/skyvern/cli/mcp_tools/blocks.py+++ b/skyvern/cli/mcp_tools/blocks.py@@ -42,6 +42,7 @@ from skyvern.schemas.workflows import (UrlBlockYAML,ValidationBlockYAML,WaitBlockYAML,+ WorkflowTriggerBlockYAML,)from ._common import ErrorCode, make_error, make_result@@ -76,6 +77,7 @@ BLOCK_TYPE_MAP: dict[str, type[BlockYAML]] = {BlockType.PDF_PARSER.value: PDFParserBlockYAML,BlockType.HUMAN_INTERACTION.value: HumanInteractionBlockYAML,BlockType.PRINT_PAGE.value: PrintPageBlockYAML,+ BlockType.WORKFLOW_TRIGGER.value: WorkflowTriggerBlockYAML,}# ---------------------------------------------------------------------------@@ -104,6 +106,7 @@ BLOCK_SUMMARIES: dict[str, str] = {"pdf_parser": "Extract structured data from a PDF document","human_interaction": "Pause workflow for human approval via email","print_page": "Print the current page to PDF",+ "workflow_trigger": "Trigger another workflow by permanent ID, with optional payload and wait-for-completion",}# ---------------------------------------------------------------------------@@ -189,6 +192,13 @@ BLOCK_EXAMPLES: dict[str, dict[str, Any]] = {"label": "open_cart","url": "https://example.com/cart",},+ "workflow_trigger": {+ "block_type": "workflow_trigger",+ "label": "trigger_sub_workflow",+ "workflow_permanent_id": "wpid_xxx",+ "payload": {"url": "{{ some_parameter }}"},+ "wait_for_completion": True,+ },}# ---------------------------------------------------------------------------diff --git a/skyvern/forge/sdk/workflow/models/block.py b/skyvern/forge/sdk/workflow/models/block.pyindex 14c36c0cb..4621e256e 100644--- a/skyvern/forge/sdk/workflow/models/block.py+++ b/skyvern/forge/sdk/workflow/models/block.py@@ -123,6 +123,9 @@ CURRENT_DATE_FORMAT = "%Y-%m-%d"# Sentinel marker for native JSON type injection via | json filter._JSON_TYPE_MARKER = "__SKYVERN_RAW_JSON__"+# Strong references to fire-and-forget asyncio tasks so they are not GC'd mid-execution.+_background_tasks: set[asyncio.Task[Any]] = set()+def _json_type_filter(value: Any) -> str:"""Jinja filter that marks a value for native JSON type injection.@@ -320,7 +323,11 @@ class Block(BaseModel, abc.ABC):return potential_template# Security: only allow real secret values for non-LLM blocks (HttpRequestBlock, CodeBlock)- is_safe_block_for_secrets = self.block_type in [BlockType.CODE, BlockType.HTTP_REQUEST]+ is_safe_block_for_secrets = self.block_type in [+ BlockType.CODE,+ BlockType.HTTP_REQUEST,+ BlockType.WORKFLOW_TRIGGER,+ ]template = jinja_sandbox_env.from_string(potential_template)@@ -5996,6 +6003,337 @@ class ConditionalBlock(Block):return next((branch for branch in self.branch_conditions if branch.is_default), None)+class WorkflowTriggerBlock(Block):+ # There is a mypy bug with Literal. Without the type: ignore, mypy will raise an error:+ # Parameter 1 of Literal[...] cannot be of type "Any"+ block_type: Literal[BlockType.WORKFLOW_TRIGGER] = BlockType.WORKFLOW_TRIGGER # type: ignore++ # The permanent ID of the target workflow to trigger+ workflow_permanent_id: str+ # Parameters/payload to pass to the triggered workflow+ payload: dict[str, Any] | None = None+ # Whether to wait for the triggered workflow to complete+ wait_for_completion: bool = True+ # Optional browser session ID for the triggered workflow+ browser_session_id: str | None = None+ # When True, the child workflow inherits the parent's browser session+ use_parent_browser_session: bool = False+ # Parameters for Jinja2 template interpolation+ parameters: list[PARAMETER_TYPE] = []++ MAX_TRIGGER_DEPTH: ClassVar[int] = 10++ def get_all_parameters(+ self,+ workflow_run_id: str,+ ) -> list[PARAMETER_TYPE]:+ return self.parameters++ async def _check_trigger_depth(self, workflow_run_id: str) -> int:+ """Check the nesting depth of workflow triggers to prevent infinite recursion.++ Note: This depth guard walks the parent_workflow_run_id chain, which is only+ populated for synchronous triggers. For async (fire-and-forget) dispatch, the+ parent may have already completed before the child runs, so circular async+ chains (A->B->A) are only blocked while A is still running. A full+ visited-workflow guard would require persistent state and is left as a future+ enhancement.+ """+ depth = 0+ current_run_id: str | None = workflow_run_id+ while current_run_id:+ if depth >= self.MAX_TRIGGER_DEPTH:+ raise InvalidWorkflowDefinition(+ f"Workflow trigger depth exceeds maximum of {self.MAX_TRIGGER_DEPTH}. "+ "This may indicate a circular workflow trigger chain."+ )+ run = await app.DATABASE.get_workflow_run(current_run_id)+ if not run or not run.parent_workflow_run_id:+ break+ current_run_id = run.parent_workflow_run_id+ depth += 1+ return depth++ def _render_template_value(+ self,+ value: str,+ workflow_run_context: WorkflowRunContext,+ ) -> Any:+ """Render a single Jinja2 template string, handling the | json filter marker."""+ rendered = self.format_block_parameter_template_from_workflow_run_context(+ value, workflow_run_context, force_include_secrets=True+ )+ if rendered.startswith(_JSON_TYPE_MARKER) and rendered.endswith(_JSON_TYPE_MARKER):+ json_str = rendered[len(_JSON_TYPE_MARKER) : -len(_JSON_TYPE_MARKER)]+ try:+ return json.loads(json_str)+ except json.JSONDecodeError:+ raise FailedToFormatJinjaStyleParameter(value, f"Raw JSON filter produced invalid JSON: {json_str}")+ elif _JSON_TYPE_MARKER in rendered:+ raise FailedToFormatJinjaStyleParameter(+ value,+ "The '| json' filter can only be used for complete value replacement. "+ "It cannot be combined with other text (e.g., 'prefix-{{ val | json }}'). "+ "Remove the surrounding text or remove the '| json' filter.",+ )+ return rendered++ def _render_templates_in_payload(+ self,+ payload: dict[str, Any],+ workflow_run_context: WorkflowRunContext,+ ) -> dict[str, Any]:+ """Recursively render Jinja2 templates in payload values."""+ resolved: dict[str, Any] = {}+ for key, value in payload.items():+ if isinstance(value, str):+ resolved[key] = self._render_template_value(value, workflow_run_context)+ elif isinstance(value, dict):+ resolved[key] = self._render_templates_in_payload(value, workflow_run_context)+ elif isinstance(value, list):+ resolved[key] = self._render_templates_in_list(value, workflow_run_context)+ else:+ resolved[key] = value+ return resolved++ def _render_templates_in_list(+ self,+ items: list[Any],+ workflow_run_context: WorkflowRunContext,+ ) -> list[Any]:+ """Recursively render Jinja2 templates in list items (strings, nested dicts, and nested lists)."""+ result: list[Any] = []+ for item in items:+ if isinstance(item, str):+ result.append(self._render_template_value(item, workflow_run_context))+ elif isinstance(item, dict):+ result.append(self._render_templates_in_payload(item, workflow_run_context))+ elif isinstance(item, list):+ result.append(self._render_templates_in_list(item, workflow_run_context))+ else:+ result.append(item)+ return result++ def format_potential_template_parameters(self, workflow_run_context: WorkflowRunContext) -> None:+ self.workflow_permanent_id = self.format_block_parameter_template_from_workflow_run_context(+ self.workflow_permanent_id, workflow_run_context, force_include_secrets=True+ )+ if self.payload:+ self.payload = self._render_templates_in_payload(self.payload, workflow_run_context)+ if self.browser_session_id:+ self.browser_session_id = self.format_block_parameter_template_from_workflow_run_context(+ self.browser_session_id, workflow_run_context, force_include_secrets=True+ )++ async def execute(+ self,+ workflow_run_id: str,+ workflow_run_block_id: str,+ organization_id: str | None = None,+ browser_session_id: str | None = None,+ **kwargs: dict,+ ) -> BlockResult:+ from skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRunStatus # noqa: PLC0415++ workflow_run_context = self.get_workflow_run_context(workflow_run_id)++ # Helper to record output and build a failed block result in one step.+ # This ensures downstream blocks referencing block_X_output see the+ # failure reason instead of "parameter not found".+ async def _fail(failure_reason: str) -> BlockResult:+ error_output = {"failure_reason": failure_reason}+ await self.record_output_parameter_value(workflow_run_context, workflow_run_id, error_output)+ return await self.build_block_result(+ success=False,+ failure_reason=failure_reason,+ output_parameter_value=error_output,+ status=BlockStatus.failed,+ workflow_run_block_id=workflow_run_block_id,+ organization_id=organization_id,+ )++ # 1. Resolve Jinja2 templates+ try:+ self.format_potential_template_parameters(workflow_run_context)+ except Exception as e:+ return await _fail(f"Failed to resolve templates: {str(e)}")++ resolved_workflow_permanent_id = self.workflow_permanent_id+ resolved_payload = self.payload+ # Browser session priority:+ # 1. Explicit browser_session_id configured on the block+ # 2. use_parent_browser_session → inherit parent's session+ # 3. Neither → None, child creates its own session+ if self.browser_session_id:+ resolved_browser_session_id = self.browser_session_id+ elif self.use_parent_browser_session and browser_session_id:+ resolved_browser_session_id = browser_session_id+ else:+ resolved_browser_session_id = None++ # 2. Check recursion depth+ try:+ await self._check_trigger_depth(workflow_run_id)+ except InvalidWorkflowDefinition as e:+ return await _fail(str(e))++ # 3. Get the organization+ if not organization_id:+ return await _fail("organization_id is required for WorkflowTriggerBlock")+ organization = await app.DATABASE.get_organization(organization_id)+ if not organization:+ return await _fail(f"Organization {organization_id} not found")++ # 4. Create WorkflowRequestBody+ workflow_request = WorkflowRequestBody(+ data=resolved_payload,+ browser_session_id=resolved_browser_session_id,+ )++ # 5. Setup the workflow run (creates WR with unique ID + parameters)+ # Save the parent's skyvern_context because setup_workflow_run and+ # execute_workflow overwrite it with the child's values. We restore+ # it after the child finishes so subsequent parent blocks get correct+ # context (logs, observability, workflow_run_id, etc.).+ from skyvern.forge.sdk.core import skyvern_context # noqa: PLC0415++ parent_context = skyvern_context.current()+ try:+ triggered_workflow_run = await app.WORKFLOW_SERVICE.setup_workflow_run(+ request_id=None,+ workflow_request=workflow_request,+ workflow_permanent_id=resolved_workflow_permanent_id,+ organization=organization,+ parent_workflow_run_id=workflow_run_id,+ )+ except Exception as e:+ error_msg = get_user_facing_exception_message(e)+ if parent_context:+ skyvern_context.set(parent_context)+ return await _fail(f"Failed to setup triggered workflow run: {error_msg}")++ triggered_run_id = triggered_workflow_run.workflow_run_id++ LOG.info(+ "Triggered workflow run",+ parent_workflow_run_id=workflow_run_id,+ triggered_workflow_run_id=triggered_run_id,+ triggered_workflow_permanent_id=resolved_workflow_permanent_id,+ wait_for_completion=self.wait_for_completion,+ )++ # 6. Execute based on wait mode+ output_data: dict[str, Any] = {}+ success = False+ if self.wait_for_completion:+ try:+ # Pass api_key=None so the child workflow's webhook (if configured)+ # is intentionally skipped. Webhook dispatch requires the caller's+ # API key, which is not available in a block execution context.+ final_run = await app.WORKFLOW_SERVICE.execute_workflow(+ workflow_run_id=triggered_run_id,+ api_key=None,+ organization=organization,+ browser_session_id=resolved_browser_session_id,+ )+ success = final_run.status == WorkflowRunStatus.completed+ output_data = {+ "workflow_run_id": triggered_run_id,+ "workflow_permanent_id": resolved_workflow_permanent_id,+ "status": str(final_run.status),+ "failure_reason": final_run.failure_reason,+ }+ # Include the child workflow's output parameters so downstream+ # blocks can reference them (e.g. block_3_output.outputs.block_2_output)+ try:+ child_output_params = (+ await app.WORKFLOW_SERVICE.get_output_parameter_workflow_run_output_parameter_tuples(+ workflow_id=final_run.workflow_id,+ workflow_run_id=triggered_run_id,+ )+ )+ child_outputs: dict[str, Any] = {}+ for output_param, run_output_param in child_output_params:+ child_outputs[output_param.key] = run_output_param.value+ output_data["outputs"] = child_outputs+ except Exception:+ LOG.warning(+ "Failed to fetch child workflow outputs",+ triggered_workflow_run_id=triggered_run_id,+ exc_info=True,+ )+ except Exception as e:+ error_msg = get_user_facing_exception_message(e)+ output_data = {+ "workflow_run_id": triggered_run_id,+ "workflow_permanent_id": resolved_workflow_permanent_id,+ "status": "failed",+ "failure_reason": f"Triggered workflow execution failed: {error_msg}",+ }+ success = False+ finally:+ # Restore parent context after child execution completes+ if parent_context:+ skyvern_context.set(parent_context)+ else:+ # Fire and forget: spawn the child workflow as a concurrent task.+ # We use asyncio.create_task instead of AsyncExecutorFactory because+ # block execution runs outside an HTTP request context, so there is+ # no FastAPI BackgroundTasks instance to schedule on.+ def _on_child_done(t: asyncio.Task[Any]) -> None:+ if t.cancelled():+ LOG.warning(+ "Async child workflow was cancelled",+ triggered_workflow_run_id=triggered_run_id,+ )+ return+ if exc := t.exception():+ LOG.error(+ "Async child workflow failed",+ triggered_workflow_run_id=triggered_run_id,+ exc_info=exc,+ )++ task = asyncio.create_task(+ app.WORKFLOW_SERVICE.execute_workflow(+ workflow_run_id=triggered_run_id,+ api_key=None,+ organization=organization,+ browser_session_id=resolved_browser_session_id,+ )+ )+ _background_tasks.add(task)+ task.add_done_callback(_background_tasks.discard)+ task.add_done_callback(_on_child_done)+ # Restore parent context AFTER create_task so the child task+ # inherits the child's context (ContextVar is copied at task+ # creation), but subsequent parent blocks see the parent's context.+ if parent_context:+ skyvern_context.set(parent_context)+ LOG.info(+ "Async workflow dispatch succeeded",+ triggered_workflow_run_id=triggered_run_id,+ triggered_workflow_permanent_id=resolved_workflow_permanent_id,+ )+ output_data = {+ "workflow_run_id": triggered_run_id,+ "workflow_permanent_id": resolved_workflow_permanent_id,+ "status": "queued",+ }+ success = True++ await self.record_output_parameter_value(workflow_run_context, workflow_run_id, output_data)++ return await self.build_block_result(+ success=success,+ failure_reason=output_data.get("failure_reason") if not success else None,+ output_parameter_value=output_data,+ status=BlockStatus.completed if success else BlockStatus.failed,+ workflow_run_block_id=workflow_run_block_id,+ organization_id=organization_id,+ )++def get_all_blocks(blocks: list[BlockTypeVar]) -> list[BlockTypeVar]:"""Recursively get "all blocks" in a workflow definition.@@ -6040,6 +6378,7 @@ BlockSubclasses = Union[FileUploadBlock,HttpRequestBlock,PrintPageBlock,+ WorkflowTriggerBlock,]BlockTypeVar = Annotated[BlockSubclasses, Field(discriminator="block_type")]diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex 1b3baae09..8dc61fdcd 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -747,7 +747,7 @@ class WorkflowService:async def execute_workflow(self,workflow_run_id: str,- api_key: str,+ api_key: str | None,organization: Organization,block_labels: list[str] | None = None,block_outputs: dict[str, Any] | None = None,diff --git a/skyvern/forge/sdk/workflow/workflow_definition_converter.py b/skyvern/forge/sdk/workflow/workflow_definition_converter.pyindex d4efce42a..ec03e25e4 100644--- a/skyvern/forge/sdk/workflow/workflow_definition_converter.py+++ b/skyvern/forge/sdk/workflow/workflow_definition_converter.py@@ -54,6 +54,7 @@ from skyvern.forge.sdk.workflow.models.block import (UrlBlock,ValidationBlock,WaitBlock,+ WorkflowTriggerBlock,)from skyvern.forge.sdk.workflow.models.parameter import (PARAMETER_TYPE,@@ -705,6 +706,18 @@ def block_yaml_to_block(parameters=print_page_block_parameters,)+ elif block_yaml.block_type == BlockType.WORKFLOW_TRIGGER:+ workflow_trigger_block_parameters = _resolve_block_parameters(block_yaml, parameters)+ return WorkflowTriggerBlock(+ **base_kwargs,+ workflow_permanent_id=block_yaml.workflow_permanent_id,+ payload=block_yaml.payload,+ wait_for_completion=block_yaml.wait_for_completion,+ browser_session_id=block_yaml.browser_session_id,+ use_parent_browser_session=block_yaml.use_parent_browser_session,+ parameters=workflow_trigger_block_parameters,+ )+raise ValueError(f"Invalid block type {block_yaml.block_type}")diff --git a/skyvern/schemas/workflows.py b/skyvern/schemas/workflows.pyindex 3bcafcb53..80b43fea3 100644--- a/skyvern/schemas/workflows.py+++ b/skyvern/schemas/workflows.py@@ -356,6 +356,7 @@ class BlockType(StrEnum):HTTP_REQUEST = "http_request"HUMAN_INTERACTION = "human_interaction"PRINT_PAGE = "print_page"+ WORKFLOW_TRIGGER = "workflow_trigger"class BlockStatus(StrEnum):@@ -912,6 +913,23 @@ class PrintPageBlockYAML(BlockYAML):parameter_keys: list[str] | None = None+class WorkflowTriggerBlockYAML(BlockYAML):+ block_type: Literal[BlockType.WORKFLOW_TRIGGER] = BlockType.WORKFLOW_TRIGGER # type: ignore++ # The permanent ID of the target workflow to trigger+ workflow_permanent_id: str+ # Parameters/payload to pass to the triggered workflow (Jinja2 templates supported in values)+ payload: dict[str, Any] | None = None+ # Whether to wait for the triggered workflow to complete before continuing+ wait_for_completion: bool = True+ # Optional browser session ID for the triggered workflow+ browser_session_id: str | None = None+ # When True, the child workflow inherits the parent's browser session+ use_parent_browser_session: bool = False+ # Parameter keys for template interpolation+ parameter_keys: list[str] | None = None++PARAMETER_YAML_SUBCLASSES = (AWSSecretParameterYAML| BitwardenLoginCredentialParameterYAML@@ -950,6 +968,7 @@ BLOCK_YAML_SUBCLASSES = (| HttpRequestBlockYAML| ConditionalBlockYAML| PrintPageBlockYAML+ | WorkflowTriggerBlockYAML)BLOCK_YAML_TYPES = Annotated[BLOCK_YAML_SUBCLASSES, Field(discriminator="block_type")]diff --git a/tests/unit/workflow/test_workflow_trigger_block.py b/tests/unit/workflow/test_workflow_trigger_block.pynew file mode 100644index 000000000..c88b61fb7--- /dev/null+++ b/tests/unit/workflow/test_workflow_trigger_block.py@@ -0,0 +1,215 @@+"""Unit tests for WorkflowTriggerBlock template rendering and depth checking."""++from __future__ import annotations++from datetime import datetime, timezone+from typing import Any+from unittest.mock import AsyncMock, MagicMock, patch++import pytest++from skyvern.forge.sdk.workflow.exceptions import InvalidWorkflowDefinition+from skyvern.forge.sdk.workflow.models.block import (+ _JSON_TYPE_MARKER,+ FailedToFormatJinjaStyleParameter,+ WorkflowTriggerBlock,+)+from skyvern.forge.sdk.workflow.models.parameter import OutputParameter+from skyvern.schemas.workflows import BlockType+++def _make_output_parameter() -> OutputParameter:+ now = datetime.now(timezone.utc)+ return OutputParameter(+ key="__output__",+ output_parameter_id="op_test",+ workflow_id="w_test",+ created_at=now,+ modified_at=now,+ )+++def _make_block(**overrides: Any) -> WorkflowTriggerBlock:+ """Create a WorkflowTriggerBlock with sensible defaults."""+ defaults: dict[str, Any] = {+ "label": "test_trigger",+ "workflow_permanent_id": "wpid_test",+ "payload": None,+ "wait_for_completion": True,+ "browser_session_id": None,+ "output_parameter": _make_output_parameter(),+ }+ defaults.update(overrides)+ return WorkflowTriggerBlock(**defaults)+++class TestRenderTemplateValue:+ """Test _render_template_value: JSON marker stripping and mid-string guard."""++ def _render(self, block: WorkflowTriggerBlock, value: str, rendered_return: str) -> Any:+ ctx = MagicMock()+ with patch.object(+ WorkflowTriggerBlock,+ "format_block_parameter_template_from_workflow_run_context",+ return_value=rendered_return,+ ):+ return block._render_template_value(value, ctx)++ def test_plain_string_passthrough(self) -> None:+ block = _make_block()+ result = self._render(block, "hello", "hello")+ assert result == "hello"++ def test_json_marker_strips_and_parses(self) -> None:+ block = _make_block()+ json_value = f'{_JSON_TYPE_MARKER}{{"key": "val"}}{_JSON_TYPE_MARKER}'+ result = self._render(block, "{{ x | json }}", json_value)+ assert result == {"key": "val"}++ def test_json_marker_with_list(self) -> None:+ block = _make_block()+ json_value = f"{_JSON_TYPE_MARKER}[1, 2, 3]{_JSON_TYPE_MARKER}"+ result = self._render(block, "{{ x | json }}", json_value)+ assert result == [1, 2, 3]++ def test_json_marker_invalid_json_raises(self) -> None:+ block = _make_block()+ json_value = f"{_JSON_TYPE_MARKER}not-valid-json{_JSON_TYPE_MARKER}"+ with pytest.raises(FailedToFormatJinjaStyleParameter):+ self._render(block, "{{ x | json }}", json_value)++ def test_mid_string_json_marker_raises(self) -> None:+ block = _make_block()+ bad_value = f"prefix-{_JSON_TYPE_MARKER}1234{_JSON_TYPE_MARKER}"+ with pytest.raises(FailedToFormatJinjaStyleParameter, match="complete value replacement"):+ self._render(block, "prefix-{{ x | json }}", bad_value)+++class TestRenderTemplatesInPayload:+ """Test _render_templates_in_payload: recursion through dicts, lists, and non-strings."""++ def _render_payload(self, block: WorkflowTriggerBlock, payload: dict[str, Any]) -> dict[str, Any]:+ ctx = MagicMock()+ with patch.object(+ WorkflowTriggerBlock,+ "format_block_parameter_template_from_workflow_run_context",+ side_effect=lambda v, _ctx, **kw: v,+ ):+ return block._render_templates_in_payload(payload, ctx)++ def test_flat_string_values(self) -> None:+ block = _make_block()+ result = self._render_payload(block, {"url": "https://example.com", "name": "test"})+ assert result == {"url": "https://example.com", "name": "test"}++ def test_non_string_values_passthrough(self) -> None:+ block = _make_block()+ result = self._render_payload(block, {"count": 42, "active": True, "data": None})+ assert result == {"count": 42, "active": True, "data": None}++ def test_nested_dict(self) -> None:+ block = _make_block()+ result = self._render_payload(block, {"outer": {"inner": "value"}})+ assert result == {"outer": {"inner": "value"}}++ def test_nested_list(self) -> None:+ block = _make_block()+ result = self._render_payload(block, {"items": ["a", "b", "c"]})+ assert result == {"items": ["a", "b", "c"]}++ def test_deeply_nested_structure(self) -> None:+ block = _make_block()+ payload = {+ "level1": {+ "level2": [+ {"level3": "deep_value"},+ [1, 2, "three"],+ ],+ },+ }+ result = self._render_payload(block, payload)+ assert result == payload++ def test_mixed_types_in_list(self) -> None:+ block = _make_block()+ result = self._render_payload(block, {"items": ["str", 42, True, None, {"nested": "dict"}]})+ assert result == {"items": ["str", 42, True, None, {"nested": "dict"}]}+++class TestCheckTriggerDepth:+ """Test _check_trigger_depth: boundary conditions at/above/below MAX_TRIGGER_DEPTH."""++ @pytest.mark.asyncio+ async def test_no_parent_returns_zero(self) -> None:+ block = _make_block()+ mock_run = MagicMock()+ mock_run.parent_workflow_run_id = None+ with patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app:+ mock_app.DATABASE.get_workflow_run = AsyncMock(return_value=mock_run)+ depth = await block._check_trigger_depth("wr_current")+ assert depth == 0++ @pytest.mark.asyncio+ async def test_single_parent_returns_one(self) -> None:+ block = _make_block()+ run_with_parent = MagicMock()+ run_with_parent.parent_workflow_run_id = "wr_parent"+ run_no_parent = MagicMock()+ run_no_parent.parent_workflow_run_id = None++ with patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app:+ mock_app.DATABASE.get_workflow_run = AsyncMock(side_effect=[run_with_parent, run_no_parent])+ depth = await block._check_trigger_depth("wr_current")+ assert depth == 1++ @pytest.mark.asyncio+ async def test_depth_at_max_raises(self) -> None:+ block = _make_block()+ runs = []+ for i in range(block.MAX_TRIGGER_DEPTH + 1):+ run = MagicMock()+ run.parent_workflow_run_id = f"wr_parent_{i}" if i < block.MAX_TRIGGER_DEPTH else None+ runs.append(run)++ with patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app:+ mock_app.DATABASE.get_workflow_run = AsyncMock(side_effect=runs)+ with pytest.raises(InvalidWorkflowDefinition, match="depth exceeds maximum"):+ await block._check_trigger_depth("wr_current")++ @pytest.mark.asyncio+ async def test_depth_just_below_max_succeeds(self) -> None:+ block = _make_block()+ runs = []+ for i in range(block.MAX_TRIGGER_DEPTH):+ run = MagicMock()+ run.parent_workflow_run_id = f"wr_parent_{i}" if i < block.MAX_TRIGGER_DEPTH - 1 else None+ runs.append(run)++ with patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app:+ mock_app.DATABASE.get_workflow_run = AsyncMock(side_effect=runs)+ depth = await block._check_trigger_depth("wr_current")+ assert depth == block.MAX_TRIGGER_DEPTH - 1++ @pytest.mark.asyncio+ async def test_run_not_found_returns_zero(self) -> None:+ block = _make_block()+ with patch("skyvern.forge.sdk.workflow.models.block.app") as mock_app:+ mock_app.DATABASE.get_workflow_run = AsyncMock(return_value=None)+ depth = await block._check_trigger_depth("wr_nonexistent")+ assert depth == 0+++class TestBlockMetadata:+ """Verify basic block properties."""++ def test_block_type(self) -> None:+ block = _make_block()+ assert block.block_type == BlockType.WORKFLOW_TRIGGER++ def test_max_trigger_depth_default(self) -> None:+ block = _make_block()+ assert block.MAX_TRIGGER_DEPTH == 10++ def test_get_all_parameters_empty(self) -> None:+ block = _make_block()+ assert block.get_all_parameters("wr_test") == []