Skip to content

Automate browser based workflows with AI

Fix: support WorkflowTriggerBlock in cached scripts (#SKY-8575) (#5320)

pedrohsdbc3e1ba290ab2
diff --git a/skyvern/core/script_generations/generate_script.py b/skyvern/core/script_generations/generate_script.py
index 2cfa53861..7db48d42e 100644
--- a/skyvern/core/script_generations/generate_script.py
+++ b/skyvern/core/script_generations/generate_script.py
@@ -2222,6 +2222,95 @@ def _build_conditional_statement(
return [conditional_call]
+def _build_workflow_trigger_statement(block: dict[str, Any]) -> cst.SimpleStatementLine:
+ """Build a skyvern.trigger_workflow statement.
+
+ WorkflowTriggerBlock makes zero LLM calls — it's pure orchestration
+ (template resolution, workflow dispatch, output collection). Executed
+ as-is during cached script runs.
+ """
+ args = [
+ cst.Arg(
+ keyword=cst.Name("workflow_permanent_id"),
+ value=_value(block.get("workflow_permanent_id", "")),
+ whitespace_after_arg=cst.ParenthesizedWhitespace(
+ indent=True,
+ last_line=cst.SimpleWhitespace(INDENT),
+ ),
+ ),
+ ]
+
+ if block.get("payload") is not None:
+ args.append(
+ cst.Arg(
+ keyword=cst.Name("payload"),
+ value=_value(block.get("payload")),
+ whitespace_after_arg=cst.ParenthesizedWhitespace(
+ indent=True,
+ last_line=cst.SimpleWhitespace(INDENT),
+ ),
+ )
+ )
+
+ if block.get("wait_for_completion") is not None:
+ args.append(
+ cst.Arg(
+ keyword=cst.Name("wait_for_completion"),
+ value=_value(block.get("wait_for_completion")),
+ whitespace_after_arg=cst.ParenthesizedWhitespace(
+ indent=True,
+ last_line=cst.SimpleWhitespace(INDENT),
+ ),
+ )
+ )
+
+ if block.get("use_parent_browser_session"):
+ args.append(
+ cst.Arg(
+ keyword=cst.Name("use_parent_browser_session"),
+ value=_value(True),
+ whitespace_after_arg=cst.ParenthesizedWhitespace(
+ indent=True,
+ last_line=cst.SimpleWhitespace(INDENT),
+ ),
+ )
+ )
+
+ if block.get("browser_session_id"):
+ args.append(
+ cst.Arg(
+ keyword=cst.Name("browser_session_id"),
+ value=_value(block.get("browser_session_id")),
+ whitespace_after_arg=cst.ParenthesizedWhitespace(
+ indent=True,
+ last_line=cst.SimpleWhitespace(INDENT),
+ ),
+ )
+ )
+
+ args.append(
+ cst.Arg(
+ keyword=cst.Name("label"),
+ value=_value(block.get("label", "")),
+ whitespace_after_arg=cst.ParenthesizedWhitespace(
+ indent=True,
+ ),
+ ),
+ )
+
+ _mark_last_arg_as_comma(args)
+ call = cst.Call(
+ func=cst.Attribute(value=cst.Name("skyvern"), attr=cst.Name("trigger_workflow")),
+ args=args,
+ whitespace_before_args=cst.ParenthesizedWhitespace(
+ indent=True,
+ last_line=cst.SimpleWhitespace(INDENT),
+ ),
+ )
+
+ return cst.SimpleStatementLine([cst.Expr(cst.Await(call))])
+
+
def _build_for_loop_statement(block_title: str, block: dict[str, Any]) -> cst.For:
"""
Build a for loop statement.
@@ -2515,6 +2604,8 @@ def _build_block_statement(
stmt = _build_http_request_statement(block)
elif block_type == "pdf_parser":
stmt = _build_pdf_parser_statement(block)
+ elif block_type == "workflow_trigger":
+ stmt = _build_workflow_trigger_statement(block)
elif block_type == "conditional":
# Conditional blocks are evaluated at runtime by the workflow engine.
# Generate a descriptive comment showing this is a runtime branch point.
diff --git a/skyvern/services/script_service.py b/skyvern/services/script_service.py
index f48e42457..1eefbab3b 100644
--- a/skyvern/services/script_service.py
+++ b/skyvern/services/script_service.py
@@ -68,6 +68,7 @@ from skyvern.forge.sdk.workflow.models.block import (
TextPromptBlock,
UrlBlock,
ValidationBlock,
+ WorkflowTriggerBlock,
)
from skyvern.forge.sdk.workflow.models.parameter import PARAMETER_TYPE, OutputParameter, ParameterType
from skyvern.forge.sdk.workflow.models.workflow import Workflow, is_adaptive_caching
@@ -2890,6 +2891,46 @@ async def goto(
await run_context.page.goto(url)
+async def trigger_workflow(
+ workflow_permanent_id: str,
+ payload: dict[str, Any] | None = None,
+ wait_for_completion: bool = True,
+ use_parent_browser_session: bool = False,
+ browser_session_id: str | None = None,
+ label: str | None = None,
+ parameters: list[str] | None = None,
+) -> dict[str, Any] | None:
+ """Execute a WorkflowTriggerBlock during cached script runs.
+
+ The trigger block makes zero LLM calls — it's pure orchestration
+ (template resolution, workflow dispatch, output collection). Safe to
+ execute as-is without caching.
+ """
+ block_validation_output = await _validate_and_get_output_parameter(label, parameters)
+ workflow_permanent_id = _render_template_with_label(workflow_permanent_id, label)
+ if browser_session_id:
+ browser_session_id = _render_template_with_label(browser_session_id, label)
+ # payload is a dict; WorkflowTriggerBlock._render_templates_in_payload resolves templates internally
+ trigger_block = WorkflowTriggerBlock(
+ workflow_permanent_id=workflow_permanent_id,
+ payload=payload,
+ wait_for_completion=wait_for_completion,
+ use_parent_browser_session=use_parent_browser_session,
+ browser_session_id=browser_session_id,
+ label=block_validation_output.label,
+ output_parameter=block_validation_output.output_parameter,
+ parameters=block_validation_output.input_parameters,
+ )
+ result = await trigger_block.execute_safe(
+ workflow_run_id=block_validation_output.workflow_run_id,
+ parent_workflow_run_block_id=block_validation_output.context.parent_workflow_run_block_id,
+ organization_id=block_validation_output.organization_id,
+ browser_session_id=block_validation_output.browser_session_id,
+ )
+ _append_to_loop_output(result.output_parameter_value, label)
+ return result.output_parameter_value
+
+
async def prompt(
prompt: str,
schema: dict[str, Any] | None = None,
diff --git a/tests/unit/test_workflow_trigger_script_generation.py b/tests/unit/test_workflow_trigger_script_generation.py
new file mode 100644
index 000000000..acf896249
--- /dev/null
+++ b/tests/unit/test_workflow_trigger_script_generation.py
@@ -0,0 +1,224 @@
+"""
+Unit tests for WorkflowTriggerBlock support in cached scripts (SKY-8575).
+
+WorkflowTriggerBlock makes zero LLM calls — it's pure orchestration
+(template resolution, workflow dispatch, output collection). These tests
+verify it generates valid code for cached script execution, especially
+inside ForLoop blocks where the original bug manifested.
+"""
+
+import ast
+
+import libcst as cst
+
+from skyvern.core.script_generations.generate_script import (
+ _build_for_loop_statement,
+ _build_workflow_trigger_statement,
+)
+
+
+class TestWorkflowTriggerStatement:
+ """Test that _build_workflow_trigger_statement generates valid skyvern.trigger_workflow() calls."""
+
+ def test_basic_trigger_generates_await_call(self) -> None:
+ """Verify basic trigger block generates await skyvern.trigger_workflow(...)."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "trigger_child",
+ "workflow_permanent_id": "wpid_123456",
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ assert "await skyvern.trigger_workflow" in code
+ assert "workflow_permanent_id" in code
+ assert "wpid_123456" in code
+ assert "label" in code
+ assert "trigger_child" in code
+
+ def test_trigger_with_payload(self) -> None:
+ """Verify payload dict is included in generated code."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "trigger_with_data",
+ "workflow_permanent_id": "wpid_999",
+ "payload": {"zip_code": "90210", "state": "CA"},
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ assert "payload" in code
+ assert "zip_code" in code
+ assert "90210" in code
+
+ def test_trigger_with_wait_for_completion(self) -> None:
+ """Verify wait_for_completion flag is included."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "sync_trigger",
+ "workflow_permanent_id": "wpid_sync",
+ "wait_for_completion": True,
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ assert "wait_for_completion" in code
+
+ def test_trigger_async_fire_and_forget(self) -> None:
+ """Verify async trigger generates wait_for_completion=False."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "async_trigger",
+ "workflow_permanent_id": "wpid_async",
+ "wait_for_completion": False,
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ assert "wait_for_completion = False" in code or "wait_for_completion=False" in code
+
+ def test_trigger_with_parent_browser_session(self) -> None:
+ """Verify use_parent_browser_session is included when True."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "shared_browser",
+ "workflow_permanent_id": "wpid_browser",
+ "use_parent_browser_session": True,
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ assert "use_parent_browser_session" in code
+
+ def test_trigger_without_parent_browser_session_omits_it(self) -> None:
+ """When use_parent_browser_session is False, it should be omitted."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "no_shared_browser",
+ "workflow_permanent_id": "wpid_no_browser",
+ "use_parent_browser_session": False,
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ assert "use_parent_browser_session" not in code
+
+ def test_trigger_with_explicit_browser_session_id(self) -> None:
+ """Verify explicit browser_session_id is included."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "explicit_session",
+ "workflow_permanent_id": "wpid_session",
+ "browser_session_id": "pbs_12345",
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ assert "browser_session_id" in code
+ assert "pbs_12345" in code
+
+ def test_trigger_compiles_as_valid_python(self) -> None:
+ """Verify the generated statement is syntactically valid Python."""
+ block = {
+ "block_type": "workflow_trigger",
+ "label": "compile_test",
+ "workflow_permanent_id": "wpid_compile",
+ "payload": {"key": "value"},
+ "wait_for_completion": True,
+ "use_parent_browser_session": True,
+ }
+
+ result = _build_workflow_trigger_statement(block)
+ code = cst.Module(body=[result]).code
+
+ # Wrap in async function so the await is valid
+ wrapped = "async def _test():\n" + "\n".join(f" {line}" for line in code.strip().splitlines())
+ ast.parse(wrapped) # Should not raise SyntaxError
+
+
+class TestWorkflowTriggerInsideForLoop:
+ """Test the key bug scenario: workflow_trigger inside a for_loop (SKY-8575)."""
+
+ def test_forloop_with_trigger_block_generates_valid_code(self) -> None:
+ """A ForLoop containing a workflow_trigger block should produce a valid async for
+ statement with the trigger call in its body — not a no-op comment."""
+ forloop_block = {
+ "block_type": "for_loop",
+ "label": "iterate_zip_codes",
+ "loop_variable_reference": "{{ zip_codes }}",
+ "loop_blocks": [
+ {
+ "block_type": "workflow_trigger",
+ "label": "trigger_per_zip",
+ "workflow_permanent_id": "wpid_child_workflow",
+ "payload": {"zip": "{{ current_value }}"},
+ "wait_for_completion": True,
+ },
+ ],
+ }
+
+ result = _build_for_loop_statement("iterate_zip_codes", forloop_block)
+ code = cst.Module(body=[result]).code
+
+ # The loop body should contain the trigger call, not 'Unknown block type'
+ assert "skyvern.trigger_workflow" in code
+ assert "Unknown block type" not in code
+ assert "wpid_child_workflow" in code
+
+ def test_forloop_with_trigger_and_extraction_generates_both(self) -> None:
+ """A ForLoop with both a trigger and extraction block should include both in the body."""
+ forloop_block = {
+ "block_type": "for_loop",
+ "label": "multi_block_loop",
+ "loop_variable_reference": "{{ items }}",
+ "loop_blocks": [
+ {
+ "block_type": "workflow_trigger",
+ "label": "trigger_step",
+ "workflow_permanent_id": "wpid_target",
+ "wait_for_completion": True,
+ },
+ {
+ "block_type": "extraction",
+ "label": "extract_step",
+ "data_extraction_goal": "Get result",
+ "task_id": "task_001",
+ },
+ ],
+ }
+
+ result = _build_for_loop_statement("multi_block_loop", forloop_block)
+ code = cst.Module(body=[result]).code
+
+ # Both blocks should appear in the loop body
+ assert "skyvern.trigger_workflow" in code
+ assert "extract_step" in code
+
+ def test_forloop_with_trigger_compiles(self) -> None:
+ """Full compilation test: ForLoop + trigger block generates valid Python."""
+ forloop_block = {
+ "block_type": "for_loop",
+ "label": "compile_loop",
+ "loop_variable_reference": "{{ data }}",
+ "loop_blocks": [
+ {
+ "block_type": "workflow_trigger",
+ "label": "child_trigger",
+ "workflow_permanent_id": "wpid_test",
+ },
+ ],
+ }
+
+ result = _build_for_loop_statement("compile_loop", forloop_block)
+ code = cst.Module(body=[result]).code
+
+ # Wrap in an async function for valid Python
+ wrapped = "async def _test():\n" + "\n".join(f" {line}" for line in code.strip().splitlines())
+ ast.parse(wrapped) # Should not raise SyntaxError