Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 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.pyindex 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, ParameterTypefrom 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.pynew file mode 100644index 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