Skip to content

Automate browser based workflows with AI

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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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.py
new file mode 100644
index 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") == []