Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix: nested for-loop script block persistence (SKY-8757) (#5404)
Aaron Perez2e72c2380c2d
diff --git a/skyvern/core/script_generations/generate_script.py b/skyvern/core/script_generations/generate_script.pyindex 2310c289f..3e7a29535 100644--- a/skyvern/core/script_generations/generate_script.py+++ b/skyvern/core/script_generations/generate_script.py@@ -9,6 +9,7 @@ from __future__ import annotationsimport hashlibimport keywordimport re+from collections import dequefrom dataclasses import dataclassfrom typing import Any@@ -537,7 +538,9 @@ def _render_value() -> cst.BaseExpression:"""Create a prompt value with template rendering logic if needed."""if not prompt_text:- return cst.SimpleString("")+ # Delegate to _value so empty/None inputs produce a valid CST node+ # (libcst rejects SimpleString("") because it lacks enclosing quotes).+ return _value(prompt_text)if "{{" in prompt_text and "}}" in prompt_text:args = [cst.Arg(value=_value(prompt_text))]if data_variable_name:@@ -1052,10 +1055,16 @@ def _build_form_filling_block_fn(navigation_goal = block.get("navigation_goal") or "Fill out the form"- # Include page.goto(url) if the block has a URL, just like _build_block_fn does+ # Include page.goto(url) if the block has a URL, just like _build_block_fn does.+ # Templated URLs (e.g. {{ outer_loop.current_value.url }}) are wrapped in+ # skyvern.render_template() so they resolve at runtime.goto_line = ""if block.get("url"):- goto_line = f" await page.goto({repr(block['url'])})\n"+ url_str = block["url"]+ if isinstance(url_str, str) and "{{" in url_str and "}}" in url_str:+ goto_line = f" await page.goto(skyvern.render_template({repr(url_str)}))\n"+ else:+ goto_line = f" await page.goto({repr(url_str)})\n"func_code = (f"async def {name}(page: SkyvernPage, context: RunContext):\n"@@ -1135,7 +1144,14 @@ def _build_block_fn(actions = _annotate_multi_field_totp_sequence(actions)if block.get("url"):- body_stmts.append(cst.parse_statement(f"await page.goto({repr(block['url'])})"))+ # Use skyvern.render_template() when the URL contains a Jinja expression+ # (e.g. {{ outer_page_loop.current_value.url }}) so it resolves at runtime+ # against workflow_run_context.values populated by skyvern.loop().+ url_str = block["url"]+ if isinstance(url_str, str) and "{{" in url_str and "}}" in url_str:+ body_stmts.append(cst.parse_statement(f"await page.goto(skyvern.render_template({repr(url_str)}))"))+ else:+ body_stmts.append(cst.parse_statement(f"await page.goto({repr(url_str)})"))# For file_download blocks inside for-loops, generate a dynamic click that uses# per-iteration context instead of hardcoded xpath/prompt from iteration 0.@@ -1406,7 +1422,7 @@ def _build_extract_statement(args = [cst.Arg(keyword=cst.Name("prompt"),- value=_value(block.get("data_extraction_goal", "")),+ value=_render_value(block.get("data_extraction_goal", ""), data_variable_name),whitespace_after_arg=cst.ParenthesizedWhitespace(indent=True,last_line=cst.SimpleWhitespace(INDENT),@@ -1414,6 +1430,8 @@ def _build_extract_statement(),cst.Arg(keyword=cst.Name("schema"),+ # data_schema is a dict/object, not a string template — _render_value only+ # handles strings, so we intentionally keep _value here.value=_value(block.get("data_schema", "")),whitespace_after_arg=cst.ParenthesizedWhitespace(indent=True,@@ -1421,6 +1439,20 @@ def _build_extract_statement(),),]+ # Emit url so the extraction block navigates to the right page on cache hit.+ # Uses _render_value so Jinja refs like {{ outer_page_loop.current_value.url }}+ # resolve at runtime from workflow_run_context.values (populated by skyvern.loop()).+ if block.get("url"):+ args.append(+ cst.Arg(+ keyword=cst.Name("url"),+ value=_render_value(block.get("url", ""), data_variable_name),+ whitespace_after_arg=cst.ParenthesizedWhitespace(+ indent=True,+ last_line=cst.SimpleWhitespace(INDENT),+ ),+ )+ )if block.get("model"):args.append(cst.Arg(@@ -2440,7 +2472,14 @@ def __build_base_task_statement(if value_to_param and prompt:prompt_value = _build_parameterized_prompt_cst(prompt, value_to_param)if prompt_value is None:- prompt_value = _value(prompt)+ if prompt:+ # Use _render_value so Jinja refs (e.g. {{ current_value }},+ # {{ outer_loop.current_value.url }}) are resolved at runtime via+ # skyvern.render_template() instead of emitted as Python literals.+ prompt_value = _render_value(prompt, data_variable_name)+ else:+ # Preserve old behavior for None/empty prompts (emits `None` vs `""`).+ prompt_value = _value(prompt)args = [cst.Arg(@@ -2456,7 +2495,10 @@ def __build_base_task_statement(args.append(cst.Arg(keyword=cst.Name("url"),- value=_value(block.get("url", "")),+ # Use _render_value so Jinja refs (e.g. {{ current_value }},+ # {{ outer_loop.current_value.url }}) resolve at runtime via+ # skyvern.render_template() instead of being emitted as literals.+ value=_render_value(block.get("url", ""), data_variable_name),whitespace_after_arg=cst.ParenthesizedWhitespace(indent=True,last_line=cst.SimpleWhitespace(INDENT),@@ -3030,8 +3072,86 @@ async def generate_workflow_script_python_code(# Inner blocks (e.g. extraction inside a loop) are nested in loop_blocks and# are NOT in the top-level blocks list, so they need separate processing here.# This follows the same pattern as task_v2 child block handling (lines 2704-2714).- for loop_block in for_loop_block.get("loop_blocks", []):- if loop_block.get("block_type") not in SCRIPT_TASK_BLOCKS:+ # Uses a BFS queue to recursively handle nested for-loops (SKY-8757).+ # Each queue entry is (block_dict, parent_forloop_label) so cache+ # invalidation propagates from the correct parent at any depth.+ loop_block_queue: deque[tuple[dict[str, Any], str]] = deque(+ (lb, for_loop_label) for lb in for_loop_block.get("loop_blocks", [])+ )+ while loop_block_queue:+ loop_block, parent_fl_label = loop_block_queue.popleft()+ loop_block_type = loop_block.get("block_type")++ # block_type is a string here (from dict.get on model_dump output),+ # not a BlockType enum — unlike transform_workflow_run.py which+ # works with ORM objects. Both compare correctly to string literals.+ #+ # Nested for-loop: create script_block for the inner for-loop itself,+ # then push its children onto the queue for processing.+ # NOTE: Do NOT call append_block_code() for nested for_loop blocks+ # (same as top-level for_loops) — they produce bare `async for`+ # statements that cause SyntaxError at module level.+ if loop_block_type == "for_loop":+ nested_label = loop_block.get("label") or f"for_loop_{loop_block.get('workflow_run_block_id')}"++ cached_nested = cached_blocks.get(nested_label)+ # Force rebuild when the nested label OR its immediate parent+ # for-loop is marked for regeneration (invalidation propagates+ # down at every nesting depth, not just from the top-level).+ use_nested_cached = (+ cached_nested is not None+ and nested_label not in updated_block_labels+ and parent_fl_label not in updated_block_labels+ )++ nested_wrbi = loop_block.get("workflow_run_block_id")+ nested_wri = loop_block.get("workflow_run_id") or run_id++ # use_nested_cached already guarantees cached_nested is not None;+ # the explicit check is retained only for mypy type narrowing.+ if (+ use_nested_cached+ and cached_nested is not None+ and cached_nested.code+ and cached_nested.run_signature+ ):+ nested_code = cached_nested.code+ nested_sig = cached_nested.run_signature+ nested_wrbi = cached_nested.workflow_run_block_id+ nested_wri = cached_nested.workflow_run_id+ else:+ # No usable cache entry (missing, incomplete, or needs update)+ # — rebuild from current run data. Mark this label as updated+ # so invalidation cascades to deeper descendants.+ updated_block_labels.add(nested_label)+ nested_stmt = _build_for_loop_statement(nested_label, loop_block)+ temp_mod = cst.Module(body=[nested_stmt])+ nested_code = temp_mod.code+ nested_sig = nested_code.strip()++ if script_id and script_revision_id and organization_id:+ ok = await create_or_update_script_block(+ block_code=nested_code,+ script_revision_id=script_revision_id,+ script_id=script_id,+ organization_id=organization_id,+ block_label=nested_label,+ update=pending,+ run_signature=nested_sig,+ workflow_run_id=nested_wri,+ workflow_run_block_id=nested_wrbi,+ input_fields=None,+ )+ if ok:+ blocks_created += 1+ else:+ blocks_failed += 1++ # Push nested for-loop's children with this loop as their parent+ loop_block_queue.extend((child, nested_label) for child in loop_block.get("loop_blocks", []))+ continue++ if loop_block_type not in SCRIPT_TASK_BLOCKS:continueinner_label = (@@ -3051,7 +3171,11 @@ async def generate_workflow_script_python_code(else:inner_actions = actions_by_task.get(loop_block.get("task_id", ""), [])if not inner_actions:- continue # No actions from agent run = can't generate cached function+ # No actions from agent run = can't generate cached function.+ # No script_block row is created; the block will be cached on+ # a future run when actions become available. This is intentional+ # — generating a stub would produce broken code.+ continueinner_fn_def = _build_block_fn(loop_block,@@ -3160,10 +3284,22 @@ async def generate_workflow_script_python_code(for flb in for_loop_blocks:label = flb.get("label") or f"for_loop_{flb.get('workflow_run_block_id')}"processed_labels.add(label)- # Also track inner block labels to prevent duplication in the- # "preserve unexecuted branch" section below- for lb in flb.get("loop_blocks", []):- inner_lbl = lb.get("label") or lb.get("title")+ # Recursively track all inner block labels (including nested for-loops)+ # to prevent duplication in the "preserve unexecuted branch" section below.+ # Use the same label derivation as the main code generation loop to ensure+ # labels match (e.g., for_loop blocks without explicit labels get the+ # "for_loop_{workflow_run_block_id}" fallback).+ inner_queue: deque[dict[str, Any]] = deque(flb.get("loop_blocks", []))+ while inner_queue:+ lb = inner_queue.popleft()+ lb_type = lb.get("block_type")+ if lb_type == "for_loop":+ inner_lbl = lb.get("label") or f"for_loop_{lb.get('workflow_run_block_id')}"+ inner_queue.extend(lb.get("loop_blocks", []))+ else:+ # Use the same 3-fallback chain as the main generation loop+ # (label → title → block_{wrb_id}) so labels always match.+ inner_lbl = lb.get("label") or lb.get("title") or f"block_{lb.get('workflow_run_block_id')}"if inner_lbl:processed_labels.add(inner_lbl)if adaptive_caching:diff --git a/skyvern/core/script_generations/transform_workflow_run.py b/skyvern/core/script_generations/transform_workflow_run.pyindex fe5473569..4c8e99ce3 100644--- a/skyvern/core/script_generations/transform_workflow_run.py+++ b/skyvern/core/script_generations/transform_workflow_run.py@@ -47,6 +47,182 @@ def _process_action_for_block(return action_dump+def _build_children_by_parent(workflow_run_blocks: list[Any]) -> dict[str | None, list[Any]]:+ """Build a parent_id -> [child_blocks] mapping for O(1) lookups."""+ result: dict[str | None, list[Any]] = defaultdict(list)+ for block in workflow_run_blocks:+ result[block.parent_workflow_run_block_id].append(block)+ return result+++def _count_descendant_actions(+ root_wrb_id: str,+ children_by_parent: dict[str | None, list[Any]],+ actions_by_task_id: dict[str, list[Action]],+) -> int:+ """Count total actions across all descendants of a run block (DFS)."""+ total = 0+ stack = list(children_by_parent.get(root_wrb_id, []))+ while stack:+ node = stack.pop()+ if node.task_id:+ total += len(actions_by_task_id.get(node.task_id, []))+ stack.extend(children_by_parent.get(node.workflow_run_block_id, []))+ return total+++def _process_forloop_children(+ forloop_run_block: Any,+ loop_blocks_def: list[dict[str, Any]],+ children_by_parent: dict[str | None, list[Any]],+ tasks_by_id: dict[str, Any],+ actions_by_task_id: dict[str, list[Action]],+ actions_by_task: dict[str, list[dict[str, Any]]],+) -> list[dict[str, Any]]:+ """Process ForLoop child blocks, merging run data into definition blocks.++ Recursively handles nested for-loops so deeply nested blocks (e.g., extraction+ inside a double-nested for-loop) get their task_id and actions merged.+ """+ # Child blocks have parent_workflow_run_block_id pointing to the ForLoop's workflow_run_block_id.+ # When the outer loop iterates N times, there are N child run blocks per label.+ # Pick the best candidate per label: prefer the block that has a task_id (for task+ # blocks) or the most grandchildren (for nested for-loops), so we don't lose data+ # if the last iteration happened to be empty.+ child_run_blocks = children_by_parent.get(forloop_run_block.workflow_run_block_id, [])+ child_run_blocks_by_label: dict[str, Any] = {}+ for b in child_run_blocks:+ if not b.label:+ continue+ existing = child_run_blocks_by_label.get(b.label)+ if existing is None:+ child_run_blocks_by_label[b.label] = b+ elif b.block_type in SCRIPT_TASK_BLOCKS:+ # Prefer the iteration with the richest execution evidence:+ # 1. has task_id beats no task_id+ # 2. when both have task_id, prefer more actions+ # 3. on action tie, prefer completed status over failed/other+ if b.task_id and not existing.task_id:+ child_run_blocks_by_label[b.label] = b+ elif b.task_id and existing.task_id:+ b_actions = len(actions_by_task_id.get(b.task_id, []))+ existing_actions = len(actions_by_task_id.get(existing.task_id, []))+ if b_actions > existing_actions:+ child_run_blocks_by_label[b.label] = b+ elif b_actions == existing_actions:+ # Break tie by status: completed > everything else.+ # Use str() in case the ORM returns a Status enum.+ b_completed = str(b.status) == "completed"+ existing_completed = str(existing.status) == "completed"+ if b_completed and not existing_completed:+ child_run_blocks_by_label[b.label] = b+ elif b.block_type == BlockType.FOR_LOOP:+ # Prefer the nested for-loop iteration that produced grandchildren.+ # On ties, break by total deep-descendant action count so the+ # iteration with usable actions wins even at 3+ nesting levels.+ existing_children = children_by_parent.get(existing.workflow_run_block_id, [])+ b_children_list = children_by_parent.get(b.workflow_run_block_id, [])+ if len(b_children_list) > len(existing_children):+ child_run_blocks_by_label[b.label] = b+ elif len(b_children_list) == len(existing_children) and b_children_list:+ b_desc = _count_descendant_actions(b.workflow_run_block_id, children_by_parent, actions_by_task_id)+ existing_desc = _count_descendant_actions(+ existing.workflow_run_block_id, children_by_parent, actions_by_task_id+ )+ if b_desc > existing_desc:+ child_run_blocks_by_label[b.label] = b++ unlabeled_children = [b for b in child_run_blocks if not b.label]+ if unlabeled_children:+ LOG.warning(+ "ForLoop has child blocks without labels - these will not be matched to loop_blocks definitions",+ forloop_label=forloop_run_block.label,+ unlabeled_count=len(unlabeled_children),+ )++ if loop_blocks_def and not child_run_blocks:+ LOG.warning(+ "ForLoop block has loop_blocks definitions but no child run blocks found",+ forloop_label=forloop_run_block.label,+ workflow_run_block_id=forloop_run_block.workflow_run_block_id,+ loop_blocks_count=len(loop_blocks_def),+ )++ updated_loop_blocks: list[dict[str, Any]] = []+ matched_count = 0+ nested_forloop_count = 0+ for loop_block_def in loop_blocks_def:+ # Shallow copy: safe because we only replace top-level keys (update(),+ # ["loop_blocks"] = ...). Do not mutate nested dicts in-place.+ if isinstance(loop_block_def, dict):+ loop_block_dump = loop_block_def.copy()+ elif hasattr(loop_block_def, "model_dump"):+ loop_block_dump = loop_block_def.model_dump()+ else:+ loop_block_dump = dict(loop_block_def)+ loop_block_label = loop_block_dump.get("label")++ child_run_block = child_run_blocks_by_label.get(loop_block_label) if loop_block_label else None++ if child_run_block and child_run_block.block_type in SCRIPT_TASK_BLOCKS and child_run_block.task_id:+ matched_count += 1+ task = tasks_by_id.get(child_run_block.task_id)+ if task:+ task_dump = task.model_dump()+ loop_block_dump.update({k: v for k, v in task_dump.items() if k not in loop_block_dump})+ loop_block_dump.update(+ {+ "task_id": child_run_block.task_id,+ "status": child_run_block.status,+ "output": child_run_block.output,+ }+ )++ actions = actions_by_task_id.get(child_run_block.task_id, [])+ action_dumps = [_process_action_for_block(action, loop_block_dump) for action in actions]+ actions_by_task[child_run_block.task_id] = action_dumps+ else:+ LOG.warning(+ "Task not found for ForLoop child block",+ task_id=child_run_block.task_id,+ forloop_label=forloop_run_block.label,+ )++ # Recursively process nested for-loops so their inner blocks+ # also get task_id and actions merged (SKY-8757).+ if child_run_block and child_run_block.block_type == BlockType.FOR_LOOP:+ nested_forloop_count += 1+ inner_loop_blocks = loop_block_dump.get("loop_blocks", [])+ if inner_loop_blocks:+ loop_block_dump["loop_blocks"] = _process_forloop_children(+ forloop_run_block=child_run_block,+ loop_blocks_def=inner_loop_blocks,+ children_by_parent=children_by_parent,+ tasks_by_id=tasks_by_id,+ actions_by_task_id=actions_by_task_id,+ actions_by_task=actions_by_task,+ )+ # Always set run block metadata for the inner for-loop, even when+ # loop_blocks is empty. generate_script.py needs workflow_run_block_id+ # for script_block creation and label fallback derivation.+ loop_block_dump["workflow_run_block_id"] = child_run_block.workflow_run_block_id+ loop_block_dump["workflow_run_id"] = child_run_block.workflow_run_id++ updated_loop_blocks.append(loop_block_dump)++ if matched_count or nested_forloop_count:+ LOG.info(+ "ForLoop child block processing summary",+ forloop_label=forloop_run_block.label,+ definition_count=len(loop_blocks_def),+ run_block_count=len(child_run_blocks),+ task_blocks_matched=matched_count,+ nested_forloops=nested_forloop_count,+ )++ return updated_loop_blocks++async def transform_workflow_run_to_code_gen_input(workflow_run_id: str, organization_id: str) -> CodeGenInput:# get the workflow run requestworkflow_run_resp = await workflow_service.get_workflow_run_response(@@ -70,7 +246,10 @@ async def transform_workflow_run_to_code_gen_input(workflow_run_id: str, organiz# get the original workflow definition blocks (with templated information)workflow_definition_blocks = workflow.workflow_definition.blocks- # get workflow run blocks for task execution data+ # Get workflow run blocks for task execution data.+ # IMPORTANT: This returns ALL descendant blocks (including for-loop children+ # and deeply nested blocks), not just top-level blocks. The batch task_id+ # collection below and _process_forloop_children both depend on this.workflow_run_blocks = await app.DATABASE.observer.get_workflow_run_blocks(workflow_run_id=workflow_run_id, organization_id=organization_id)@@ -119,6 +298,9 @@ async def transform_workflow_run_to_code_gen_input(workflow_run_id: str, organizactions_by_task: dict[str, list[dict[str, Any]]] = {}task_v2_child_blocks = {}+ # Pre-build parent -> children mapping for O(1) lookups in for-loop processing+ children_by_parent = _build_children_by_parent(workflow_run_blocks)+# Loop through workflow run blocks and match to original definition blocks by labelfor definition_block in workflow_definition_blocks:# if definition_block.block_type == BlockType.TaskV2:@@ -202,71 +384,14 @@ async def transform_workflow_run_to_code_gen_input(workflow_run_id: str, organiz)if run_block.block_type == BlockType.FOR_LOOP:- # Process ForLoop child blocks to get actions for task blocks inside the loop- # Child blocks have parent_workflow_run_block_id pointing to the ForLoop's workflow_run_block_id- child_run_blocks = [- b for b in workflow_run_blocks if b.parent_workflow_run_block_id == run_block.workflow_run_block_id- ]- # Create mapping of child run blocks by label- child_run_blocks_by_label = {b.label: b for b in child_run_blocks if b.label}-- # Warn about any unlabeled child blocks that won't be matched- unlabeled_children = [b for b in child_run_blocks if not b.label]- if unlabeled_children:- LOG.warning(- "ForLoop has child blocks without labels - these will not be matched to loop_blocks definitions",- forloop_label=run_block.label,- unlabeled_count=len(unlabeled_children),- )-- # Get loop_blocks from the definition block- loop_blocks = final_dump.get("loop_blocks", [])-- if loop_blocks and not child_run_blocks:- LOG.warning(- "ForLoop block has loop_blocks definitions but no child run blocks found",- forloop_label=run_block.label,- workflow_run_block_id=run_block.workflow_run_block_id,- loop_blocks_count=len(loop_blocks),- )- updated_loop_blocks = []-- for loop_block_def in loop_blocks:- loop_block_dump = loop_block_def.copy() if isinstance(loop_block_def, dict) else loop_block_def- loop_block_label = loop_block_dump.get("label")-- # Find matching child run block- child_run_block = child_run_blocks_by_label.get(loop_block_label) if loop_block_label else None-- if child_run_block and child_run_block.block_type in SCRIPT_TASK_BLOCKS and child_run_block.task_id:- # Use pre-fetched task data (batch fetched)- task = tasks_by_id.get(child_run_block.task_id)- if task:- task_dump = task.model_dump()- loop_block_dump.update({k: v for k, v in task_dump.items() if k not in loop_block_dump})- loop_block_dump.update(- {- "task_id": child_run_block.task_id,- "status": child_run_block.status,- "output": child_run_block.output,- }- )-- # Use pre-fetched actions (batch fetched)- actions = actions_by_task_id.get(child_run_block.task_id, [])- action_dumps = [_process_action_for_block(action, loop_block_dump) for action in actions]- actions_by_task[child_run_block.task_id] = action_dumps- else:- LOG.warning(- "Task not found for ForLoop child block",- task_id=child_run_block.task_id,- forloop_label=run_block.label,- )-- updated_loop_blocks.append(loop_block_dump)-- # Update final_dump with the processed loop_blocks- final_dump["loop_blocks"] = updated_loop_blocks+ final_dump["loop_blocks"] = _process_forloop_children(+ forloop_run_block=run_block,+ loop_blocks_def=final_dump.get("loop_blocks", []),+ children_by_parent=children_by_parent,+ tasks_by_id=tasks_by_id,+ actions_by_task_id=actions_by_task_id,+ actions_by_task=actions_by_task,+ )final_dump["workflow_run_id"] = workflow_run_idif run_block:diff --git a/skyvern/forge/sdk/db/repositories/scripts.py b/skyvern/forge/sdk/db/repositories/scripts.pyindex b97cf9725..0f1b82b87 100644--- a/skyvern/forge/sdk/db/repositories/scripts.py+++ b/skyvern/forge/sdk/db/repositories/scripts.py@@ -555,6 +555,12 @@ class ScriptsRepository(BaseRepository):WorkflowScriptModel.workflow_permanent_id == workflow_permanent_id,WorkflowScriptModel.cache_key_value == cache_key_value,WorkflowScriptModel.deleted_at.is_(None),+ # Exclude soft-deleted Script revisions so an empty/failed revision+ # left behind by a crashed regeneration cannot be returned as the+ # "latest" version for this cache key. Without this filter, runs+ # observe has_script=True with script_block_count=0 (empty_blocks_detected+ # regression tracked under SKY-8757).+ ScriptModel.deleted_at.is_(None),))diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex ef319100d..768c5099c 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -1125,6 +1125,14 @@ class WorkflowService:finalize=True, # Force regeneration to ensure field mappings have complete action datahas_conditionals=has_conditionals,)+ else:+ LOG.info(+ "Skipping post-run script generation due to run status",+ workflow_run_id=workflow_run_id,+ workflow_permanent_id=workflow.workflow_permanent_id,+ pre_finally_status=pre_finally_status,+ blocks_to_update_count=len(blocks_to_update),+ )# Trigger AI Script Reviewer for adaptive caching workflows# Include terminated and failed runs — the reviewer filters to only@@ -2441,7 +2449,9 @@ class WorkflowService:"For-loop child blocks marked for caching",parent_label=block.label,child_labels=new_labels,+ child_count=len(new_labels),workflow_run_id=workflow_run_id,+ workflow_permanent_id=workflow.workflow_permanent_id,)workflow_run, should_stop = await self._handle_block_result_status(@@ -5052,7 +5062,8 @@ class WorkflowService:block_labels=block_labels,code_gen=code_gen,workflow_run_id=workflow_run.workflow_run_id,- blocks_to_update=list(blocks_to_update),+ workflow_permanent_id=workflow.workflow_permanent_id,+ blocks_to_update_count=len(blocks_to_update),)if block_labels and not code_gen:@@ -5210,17 +5221,27 @@ class WorkflowService:updated_block_labels=blocks_to_update,)- # If generation failed (e.g. syntax error), clean up the empty script row- # to avoid orphaned versions that skip version numbers on next regeneration.+ # If generation failed (e.g. syntax error, S3/DB contention), clean up+ # the empty script row to avoid orphaned versions that skip version+ # numbers AND to prevent later runs from finding a published revision+ # with zero blocks (the empty_blocks_detected regression from SKY-8757).+ # Check BOTH files and blocks — a revision with main.py but zero+ # script_block rows still fails code-mode execution.script_files = await app.DATABASE.scripts.get_script_files(script_revision_id=regenerated_script.script_revision_id,organization_id=workflow.organization_id,)- if not script_files:+ script_blocks = await app.DATABASE.scripts.get_script_blocks_by_script_revision_id(+ script_revision_id=regenerated_script.script_revision_id,+ organization_id=workflow.organization_id,+ )+ if not script_files or not script_blocks:LOG.warning(- "Script generation produced no files, soft-deleting empty version",+ "Script generation produced no files or no blocks, soft-deleting empty version",script_id=regenerated_script.script_id,version=regenerated_script.version,+ script_file_count=len(script_files),+ script_block_count=len(script_blocks),)await app.DATABASE.scripts.soft_delete_script_by_revision(script_revision_id=regenerated_script.script_revision_id,@@ -5271,6 +5292,14 @@ class WorkflowService:await _regenerate_script()return+ LOG.debug(+ "Creating new cached script (first run for this cache key)",+ workflow_permanent_id=workflow.workflow_permanent_id,+ workflow_run_id=workflow_run.workflow_run_id,+ cache_key_value=rendered_cache_key_value,+ blocks_to_update_count=len(blocks_to_update),+ )+created_script = await app.DATABASE.scripts.create_script(organization_id=workflow.organization_id,run_id=workflow_run.workflow_run_id,@@ -5284,6 +5313,32 @@ class WorkflowService:cached_script=None,updated_block_labels=None,)++ # Mirror the regeneration path's post-write guard: if this first-time+ # generation produced no files or no blocks, soft-delete the empty revision+ # so it can't be observed by subsequent runs. (SKY-8757 follow-up.)+ script_files = await app.DATABASE.scripts.get_script_files(+ script_revision_id=created_script.script_revision_id,+ organization_id=workflow.organization_id,+ )+ script_blocks = await app.DATABASE.scripts.get_script_blocks_by_script_revision_id(+ script_revision_id=created_script.script_revision_id,+ organization_id=workflow.organization_id,+ )+ if not script_files or not script_blocks:+ LOG.warning(+ "First-time script generation produced no files or no blocks, soft-deleting empty version",+ script_id=created_script.script_id,+ version=created_script.version,+ script_file_count=len(script_files),+ script_block_count=len(script_blocks),+ )+ await app.DATABASE.scripts.soft_delete_script_by_revision(+ script_revision_id=created_script.script_revision_id,+ organization_id=workflow.organization_id,+ )+ return+aio_task_primary_key = f"{created_script.script_id}_{created_script.version}"if aio_task_primary_key in app.ARTIFACT_MANAGER.upload_aiotasks_map:aio_tasks = app.ARTIFACT_MANAGER.upload_aiotasks_map[aio_task_primary_key]diff --git a/skyvern/services/workflow_script_service.py b/skyvern/services/workflow_script_service.pyindex 1ad33f6fd..0e7e62ba9 100644--- a/skyvern/services/workflow_script_service.py+++ b/skyvern/services/workflow_script_service.py@@ -3,6 +3,7 @@ import hashlibimport reimport timeimport urllib.parse+from collections import dequefrom typing import Any, NamedTupleimport structlog@@ -554,10 +555,24 @@ async def generate_workflow_script(updated_block_labels.update(missing_labels)updated_block_labels.add(settings.WORKFLOW_START_BLOCK_LABEL)+ # Count all descendant blocks inside top-level for-loops (task, extraction,+ # nested for-loops, etc). Does not include blocks inside task_v2 or conditionals.+ forloop_descendant_count = 0+ for blk in codegen_input.workflow_blocks:+ if blk.get("block_type") == "for_loop":+ q: deque[dict[str, Any]] = deque(blk.get("loop_blocks", []))+ while q:+ inner = q.popleft()+ forloop_descendant_count += 1+ if inner.get("block_type") == "for_loop":+ q.extend(inner.get("loop_blocks", []))+LOG.info("Script generation block analysis",workflow_run_id=workflow_run.workflow_run_id,- total_blocks=len(block_labels),+ workflow_permanent_id=workflow.workflow_permanent_id,+ total_top_level_blocks=len(block_labels),+ forloop_descendant_blocks=forloop_descendant_count,cached_blocks=len(cached_block_sources),missing_blocks=len(missing_labels),blocks_to_regenerate=len(updated_block_labels),@@ -584,6 +599,8 @@ async def generate_workflow_script(generation_duration_ms = (time.monotonic() - generation_start) * 1000LOG.error("Failed to generate workflow script source",+ workflow_run_id=workflow_run.workflow_run_id,+ workflow_permanent_id=workflow.workflow_permanent_id,duration_ms=round(generation_duration_ms, 1),exc_info=True,)@@ -598,6 +615,7 @@ async def generate_workflow_script("Script generation completed",workflow_run_id=workflow_run.workflow_run_id,workflow_id=workflow.workflow_id,+ workflow_permanent_id=workflow.workflow_permanent_id,cache_key_value=rendered_cache_key_value,duration_ms=round(generation_duration_ms, 1),script_size_bytes=len(python_src.encode("utf-8")),@@ -614,12 +632,16 @@ async def generate_workflow_script(blocks_failed=blocks_failed,)- # Guard: if every block creation failed, do not persist a zero-block script- if blocks_created == 0 and blocks_failed > 0:+ # Guard: never persist a zero-block script, regardless of whether the blocks+ # failed or were silently skipped (e.g. generate_script.py:2901 fast-skip for+ # blocks with no actions and no task_id). Publishing an empty revision is the+ # `empty_blocks_detected=True` regression tracked under SKY-8757.+ if blocks_created == 0:LOG.error(- "All script block creations failed — skipping WorkflowScript creation",+ "Script generation produced zero blocks — skipping WorkflowScript creation",workflow_permanent_id=workflow.workflow_permanent_id,script_id=script.script_id,+ script_revision_id=script.script_revision_id,blocks_failed=blocks_failed,)returndiff --git a/tests/unit/test_nested_forloop_script_generation.py b/tests/unit/test_nested_forloop_script_generation.pynew file mode 100644index 000000000..31b791231--- /dev/null+++ b/tests/unit/test_nested_forloop_script_generation.py@@ -0,0 +1,1043 @@+"""Tests for nested for-loop script generation and transformation (SKY-8757).++Covers:+1. _process_forloop_children in transform_workflow_run.py — recursive merging+ of task data for nested for-loop children.+2. generate_workflow_script_python_code in generate_script.py — code generation+ for nested for-loop inner blocks (script_block creation + function bodies).+"""++import ast+from typing import Any+from unittest.mock import AsyncMock, MagicMock, patch++import pytest++from skyvern.core.script_generations.transform_workflow_run import (+ _build_children_by_parent,+ _process_forloop_children,+)+from skyvern.schemas.workflows import BlockType+from skyvern.webeye.actions.actions import Action+++# ---------------------------------------------------------------------------+# Part 1: _process_forloop_children tests+# ---------------------------------------------------------------------------+class TestProcessForloopChildren:+ """Test recursive merging of for-loop children in transform_workflow_run."""++ def test_single_level_merges_task_data(self) -> None:+ """Direct task children get task_id and actions merged."""+ forloop_run_block = MagicMock()+ forloop_run_block.workflow_run_block_id = "wfrb_outer"+ forloop_run_block.label = "outer_loop"++ child_run_block = MagicMock()+ child_run_block.workflow_run_block_id = "wfrb_child"+ child_run_block.parent_workflow_run_block_id = "wfrb_outer"+ child_run_block.block_type = "extraction"+ child_run_block.label = "extract_data"+ child_run_block.task_id = "task_1"+ child_run_block.status = "completed"+ child_run_block.output = {"data": "extracted"}+ child_run_block.workflow_run_id = "wr_1"++ mock_task = MagicMock()+ mock_task.model_dump.return_value = {"task_id": "task_1", "navigation_goal": "Extract"}++ mock_action = MagicMock(spec=Action)+ mock_action.model_dump.return_value = {"action_type": "extract", "action_id": "a1"}+ mock_action.get_xpath.return_value = "//div"+ mock_action.has_mini_agent = False+ mock_action.action_type = "extract"+ mock_action.task_id = "task_1"++ loop_blocks_def = [+ {"block_type": "extraction", "label": "extract_data", "data_extraction_goal": "Extract"},+ ]++ actions_by_task: dict[str, list[dict[str, Any]]] = {}+ all_blocks = [forloop_run_block, child_run_block]++ result = _process_forloop_children(+ forloop_run_block=forloop_run_block,+ loop_blocks_def=loop_blocks_def,+ children_by_parent=_build_children_by_parent(all_blocks),+ tasks_by_id={"task_1": mock_task},+ actions_by_task_id={"task_1": [mock_action]},+ actions_by_task=actions_by_task,+ )++ assert len(result) == 1+ assert result[0]["task_id"] == "task_1"+ assert result[0]["status"] == "completed"+ assert "task_1" in actions_by_task++ def test_nested_forloop_recurses_into_children(self) -> None:+ """Nested for-loop's children should get task data merged recursively."""+ outer_run = MagicMock()+ outer_run.workflow_run_block_id = "wfrb_outer"+ outer_run.label = "outer_loop"++ inner_run = MagicMock()+ inner_run.workflow_run_block_id = "wfrb_inner"+ inner_run.parent_workflow_run_block_id = "wfrb_outer"+ inner_run.block_type = BlockType.FOR_LOOP+ inner_run.label = "inner_loop"+ inner_run.task_id = None+ inner_run.workflow_run_id = "wr_1"++ grandchild_run = MagicMock()+ grandchild_run.workflow_run_block_id = "wfrb_grandchild"+ grandchild_run.parent_workflow_run_block_id = "wfrb_inner"+ grandchild_run.block_type = "extraction"+ grandchild_run.label = "deep_extract"+ grandchild_run.task_id = "task_deep"+ grandchild_run.status = "completed"+ grandchild_run.output = {"deep": True}+ grandchild_run.workflow_run_id = "wr_1"++ mock_task = MagicMock()+ mock_task.model_dump.return_value = {"task_id": "task_deep"}++ mock_action = MagicMock(spec=Action)+ mock_action.model_dump.return_value = {"action_type": "extract"}+ mock_action.get_xpath.return_value = "//span"+ mock_action.has_mini_agent = False+ mock_action.action_type = "extract"+ mock_action.task_id = "task_deep"++ loop_blocks_def = [+ {+ "block_type": "for_loop",+ "label": "inner_loop",+ "loop_blocks": [+ {"block_type": "extraction", "label": "deep_extract", "data_extraction_goal": "Deep extract"},+ ],+ },+ ]++ all_run_blocks = [outer_run, inner_run, grandchild_run]+ actions_by_task: dict[str, list[dict[str, Any]]] = {}++ result = _process_forloop_children(+ forloop_run_block=outer_run,+ loop_blocks_def=loop_blocks_def,+ children_by_parent=_build_children_by_parent(all_run_blocks),+ tasks_by_id={"task_deep": mock_task},+ actions_by_task_id={"task_deep": [mock_action]},+ actions_by_task=actions_by_task,+ )++ assert len(result) == 1+ inner_loop = result[0]+ assert inner_loop["block_type"] == "for_loop"+ assert inner_loop["workflow_run_block_id"] == "wfrb_inner"++ # Verify the grandchild got task data merged+ inner_children = inner_loop.get("loop_blocks", [])+ assert len(inner_children) == 1+ assert inner_children[0]["task_id"] == "task_deep"+ assert "task_deep" in actions_by_task++ def test_multi_iteration_picks_best_task_block(self) -> None:+ """When the outer loop iterates multiple times, the run block with task_id should win."""+ outer_run = MagicMock()+ outer_run.workflow_run_block_id = "wfrb_outer"+ outer_run.parent_workflow_run_block_id = None+ outer_run.label = "outer_loop"++ # Iteration 1: has task_id (good)+ child_iter1 = MagicMock()+ child_iter1.workflow_run_block_id = "wfrb_child_iter1"+ child_iter1.parent_workflow_run_block_id = "wfrb_outer"+ child_iter1.block_type = "extraction"+ child_iter1.label = "extract_data"+ child_iter1.task_id = "task_good"+ child_iter1.status = "completed"+ child_iter1.output = {"data": True}+ child_iter1.workflow_run_id = "wr_1"++ # Iteration 2: no task_id (empty iteration)+ child_iter2 = MagicMock()+ child_iter2.workflow_run_block_id = "wfrb_child_iter2"+ child_iter2.parent_workflow_run_block_id = "wfrb_outer"+ child_iter2.block_type = "extraction"+ child_iter2.label = "extract_data"+ child_iter2.task_id = None+ child_iter2.status = None+ child_iter2.output = None+ child_iter2.workflow_run_id = "wr_1"++ mock_task = MagicMock()+ mock_task.model_dump.return_value = {"task_id": "task_good"}++ mock_action = MagicMock(spec=Action)+ mock_action.model_dump.return_value = {"action_type": "extract"}+ mock_action.get_xpath.return_value = "//div"+ mock_action.has_mini_agent = False+ mock_action.action_type = "extract"+ mock_action.task_id = "task_good"++ loop_blocks_def = [+ {"block_type": "extraction", "label": "extract_data", "data_extraction_goal": "Extract"},+ ]++ actions_by_task: dict[str, list[dict[str, Any]]] = {}+ # child_iter2 comes after child_iter1 — old code would keep iter2 (no task_id)+ all_blocks = [outer_run, child_iter1, child_iter2]++ result = _process_forloop_children(+ forloop_run_block=outer_run,+ loop_blocks_def=loop_blocks_def,+ children_by_parent=_build_children_by_parent(all_blocks),+ tasks_by_id={"task_good": mock_task},+ actions_by_task_id={"task_good": [mock_action]},+ actions_by_task=actions_by_task,+ )++ assert len(result) == 1+ # Should pick the block with task_id, not the empty one+ assert result[0]["task_id"] == "task_good"+ assert "task_good" in actions_by_task++ def test_multi_iteration_prefers_richer_actions(self) -> None:+ """When both iterations have task_id, prefer the one with more actions."""+ outer_run = MagicMock()+ outer_run.workflow_run_block_id = "wfrb_outer"+ outer_run.parent_workflow_run_block_id = None+ outer_run.label = "outer_loop"++ # Iteration 1: has task_id but only 1 action (partial)+ child_iter1 = MagicMock()+ child_iter1.workflow_run_block_id = "wfrb_child_iter1"+ child_iter1.parent_workflow_run_block_id = "wfrb_outer"+ child_iter1.block_type = "extraction"+ child_iter1.label = "extract_data"+ child_iter1.task_id = "task_partial"+ child_iter1.status = "completed"+ child_iter1.output = {}+ child_iter1.workflow_run_id = "wr_1"++ # Iteration 2: has task_id with 3 actions (richer)+ child_iter2 = MagicMock()+ child_iter2.workflow_run_block_id = "wfrb_child_iter2"+ child_iter2.parent_workflow_run_block_id = "wfrb_outer"+ child_iter2.block_type = "extraction"+ child_iter2.label = "extract_data"+ child_iter2.task_id = "task_rich"+ child_iter2.status = "completed"+ child_iter2.output = {"data": "full"}+ child_iter2.workflow_run_id = "wr_1"++ mock_task_partial = MagicMock()+ mock_task_partial.model_dump.return_value = {"task_id": "task_partial"}+ mock_task_rich = MagicMock()+ mock_task_rich.model_dump.return_value = {"task_id": "task_rich"}++ def _make_action(task_id: str) -> MagicMock:+ a = MagicMock(spec=Action)+ a.model_dump.return_value = {"action_type": "extract"}+ a.get_xpath.return_value = "//div"+ a.has_mini_agent = False+ a.action_type = "extract"+ a.task_id = task_id+ return a++ loop_blocks_def = [+ {"block_type": "extraction", "label": "extract_data", "data_extraction_goal": "Extract"},+ ]++ actions_by_task: dict[str, list[dict[str, Any]]] = {}+ all_blocks = [outer_run, child_iter1, child_iter2]++ result = _process_forloop_children(+ forloop_run_block=outer_run,+ loop_blocks_def=loop_blocks_def,+ children_by_parent=_build_children_by_parent(all_blocks),+ tasks_by_id={"task_partial": mock_task_partial, "task_rich": mock_task_rich},+ actions_by_task_id={+ "task_partial": [_make_action("task_partial")],+ "task_rich": [_make_action("task_rich"), _make_action("task_rich"), _make_action("task_rich")],+ },+ actions_by_task=actions_by_task,+ )++ assert len(result) == 1+ # Should pick task_rich (3 actions) over task_partial (1 action)+ assert result[0]["task_id"] == "task_rich"+ assert "task_rich" in actions_by_task++ def test_multi_iteration_nested_forloop_picks_richest(self) -> None:+ """When a nested for-loop has multiple iterations, pick the one with most grandchildren."""+ outer_run = MagicMock()+ outer_run.workflow_run_block_id = "wfrb_outer"+ outer_run.parent_workflow_run_block_id = None+ outer_run.label = "outer_loop"++ # Iteration 1 of inner loop: has grandchildren+ inner_iter1 = MagicMock()+ inner_iter1.workflow_run_block_id = "wfrb_inner_iter1"+ inner_iter1.parent_workflow_run_block_id = "wfrb_outer"+ inner_iter1.block_type = BlockType.FOR_LOOP+ inner_iter1.label = "inner_loop"+ inner_iter1.task_id = None+ inner_iter1.workflow_run_id = "wr_1"++ grandchild = MagicMock()+ grandchild.workflow_run_block_id = "wfrb_grandchild"+ grandchild.parent_workflow_run_block_id = "wfrb_inner_iter1"+ grandchild.block_type = "extraction"+ grandchild.label = "deep_extract"+ grandchild.task_id = "task_deep"+ grandchild.status = "completed"+ grandchild.output = {"deep": True}+ grandchild.workflow_run_id = "wr_1"++ # Iteration 2 of inner loop: empty (no grandchildren)+ inner_iter2 = MagicMock()+ inner_iter2.workflow_run_block_id = "wfrb_inner_iter2"+ inner_iter2.parent_workflow_run_block_id = "wfrb_outer"+ inner_iter2.block_type = BlockType.FOR_LOOP+ inner_iter2.label = "inner_loop"+ inner_iter2.task_id = None+ inner_iter2.workflow_run_id = "wr_1"++ mock_task = MagicMock()+ mock_task.model_dump.return_value = {"task_id": "task_deep"}++ mock_action = MagicMock(spec=Action)+ mock_action.model_dump.return_value = {"action_type": "extract"}+ mock_action.get_xpath.return_value = "//span"+ mock_action.has_mini_agent = False+ mock_action.action_type = "extract"+ mock_action.task_id = "task_deep"++ loop_blocks_def = [+ {+ "block_type": "for_loop",+ "label": "inner_loop",+ "loop_blocks": [+ {"block_type": "extraction", "label": "deep_extract", "data_extraction_goal": "Deep"},+ ],+ },+ ]++ actions_by_task: dict[str, list[dict[str, Any]]] = {}+ # inner_iter2 comes last but has no grandchildren — should pick inner_iter1+ all_blocks = [outer_run, inner_iter1, grandchild, inner_iter2]++ result = _process_forloop_children(+ forloop_run_block=outer_run,+ loop_blocks_def=loop_blocks_def,+ children_by_parent=_build_children_by_parent(all_blocks),+ tasks_by_id={"task_deep": mock_task},+ actions_by_task_id={"task_deep": [mock_action]},+ actions_by_task=actions_by_task,+ )++ assert len(result) == 1+ inner = result[0]+ # Should have picked inner_iter1 (has grandchildren)+ assert inner["workflow_run_block_id"] == "wfrb_inner_iter1"+ # Grandchild should have task data merged+ inner_children = inner.get("loop_blocks", [])+ assert len(inner_children) == 1+ assert inner_children[0]["task_id"] == "task_deep"+ assert "task_deep" in actions_by_task++ def test_nested_forloop_tie_broken_by_descendant_actions(self) -> None:+ """When two nested for-loop iterations have the same child count,+ prefer the one whose descendants have more actions."""+ outer_run = MagicMock()+ outer_run.workflow_run_block_id = "wfrb_outer"+ outer_run.parent_workflow_run_block_id = None+ outer_run.label = "outer_loop"++ # Iteration 1: 1 grandchild, no actions+ inner_iter1 = MagicMock()+ inner_iter1.workflow_run_block_id = "wfrb_inner_iter1"+ inner_iter1.parent_workflow_run_block_id = "wfrb_outer"+ inner_iter1.block_type = BlockType.FOR_LOOP+ inner_iter1.label = "inner_loop"+ inner_iter1.task_id = None+ inner_iter1.workflow_run_id = "wr_1"++ gc1 = MagicMock()+ gc1.workflow_run_block_id = "wfrb_gc1"+ gc1.parent_workflow_run_block_id = "wfrb_inner_iter1"+ gc1.block_type = "extraction"+ gc1.label = "deep_extract"+ gc1.task_id = "task_empty"+ gc1.status = "completed"+ gc1.output = {}+ gc1.workflow_run_id = "wr_1"++ # Iteration 2: 1 grandchild, with actions (richer)+ inner_iter2 = MagicMock()+ inner_iter2.workflow_run_block_id = "wfrb_inner_iter2"+ inner_iter2.parent_workflow_run_block_id = "wfrb_outer"+ inner_iter2.block_type = BlockType.FOR_LOOP+ inner_iter2.label = "inner_loop"+ inner_iter2.task_id = None+ inner_iter2.workflow_run_id = "wr_1"++ gc2 = MagicMock()+ gc2.workflow_run_block_id = "wfrb_gc2"+ gc2.parent_workflow_run_block_id = "wfrb_inner_iter2"+ gc2.block_type = "extraction"+ gc2.label = "deep_extract"+ gc2.task_id = "task_rich"+ gc2.status = "completed"+ gc2.output = {"data": True}+ gc2.workflow_run_id = "wr_1"++ mock_task = MagicMock()+ mock_task.model_dump.return_value = {"task_id": "task_rich"}++ mock_action = MagicMock(spec=Action)+ mock_action.model_dump.return_value = {"action_type": "extract"}+ mock_action.get_xpath.return_value = "//div"+ mock_action.has_mini_agent = False+ mock_action.action_type = "extract"+ mock_action.task_id = "task_rich"++ loop_blocks_def = [+ {+ "block_type": "for_loop",+ "label": "inner_loop",+ "loop_blocks": [+ {"block_type": "extraction", "label": "deep_extract", "data_extraction_goal": "Extract"},+ ],+ },+ ]++ actions_by_task: dict[str, list[dict[str, Any]]] = {}+ # Both iterations have 1 grandchild, but only iter2's grandchild has actions+ all_blocks = [outer_run, inner_iter1, gc1, inner_iter2, gc2]++ result = _process_forloop_children(+ forloop_run_block=outer_run,+ loop_blocks_def=loop_blocks_def,+ children_by_parent=_build_children_by_parent(all_blocks),+ tasks_by_id={"task_rich": mock_task},+ actions_by_task_id={"task_rich": [mock_action]}, # only task_rich has actions+ actions_by_task=actions_by_task,+ )++ assert len(result) == 1+ inner = result[0]+ # Should pick iter2 (descendant has actions) over iter1 (no actions)+ assert inner["workflow_run_block_id"] == "wfrb_inner_iter2"++ def test_no_matching_run_block_preserves_definition(self) -> None:+ """If no run block matches a definition child, the definition is preserved unchanged."""+ forloop_run = MagicMock()+ forloop_run.workflow_run_block_id = "wfrb_loop"+ forloop_run.label = "loop"++ loop_blocks_def = [+ {"block_type": "extraction", "label": "unexecuted_block"},+ ]++ actions_by_task: dict[str, list[dict[str, Any]]] = {}++ result = _process_forloop_children(+ forloop_run_block=forloop_run,+ loop_blocks_def=loop_blocks_def,+ children_by_parent=_build_children_by_parent([forloop_run]),+ tasks_by_id={},+ actions_by_task_id={},+ actions_by_task=actions_by_task,+ )++ assert len(result) == 1+ assert result[0]["label"] == "unexecuted_block"+ assert "task_id" not in result[0]+++# ---------------------------------------------------------------------------+# Part 2: generate_workflow_script_python_code tests for nested for-loops+# ---------------------------------------------------------------------------+class TestNestedForloopCodeGeneration:+ """Test that nested for-loops generate correct script blocks and code."""++ @pytest.mark.asyncio+ async def test_nested_forloop_creates_script_blocks_for_all_levels(self) -> None:+ """A double-nested for-loop should create script_blocks for:+ 1. Outer for-loop+ 2. Inner for-loop+ 3. Inner task blocks+ """+ from skyvern.core.script_generations.generate_script import generate_workflow_script_python_code++ blocks = [+ {+ "block_type": "for_loop",+ "label": "outer_loop",+ "loop_variable_reference": "{{ urls }}",+ "workflow_run_block_id": "wfrb_outer",+ "loop_blocks": [+ {+ "block_type": "for_loop",+ "label": "inner_loop",+ "loop_variable_reference": "{{ documents }}",+ "workflow_run_block_id": "wfrb_inner",+ "loop_blocks": [+ {+ "block_type": "extraction",+ "label": "extract_data",+ "data_extraction_goal": "Get content",+ "task_id": "task_extract",+ "workflow_run_block_id": "wfrb_extract",+ },+ ],+ },+ ],+ },+ ]++ actions_by_task = {+ "task_extract": [+ {+ "action_type": "extract",+ "action_id": "action_1",+ "xpath": "//div[@id='content']",+ "element_id": "elem_1",+ "text": None,+ "data_extraction_goal": "Get content",+ },+ ],+ }++ workflow = {+ "workflow_id": "wf_test",+ "title": "Nested ForLoop Test",+ "workflow_definition": {"parameters": []},+ }++ mock_create_script_block = AsyncMock(return_value=True)++ with (+ patch(+ "skyvern.core.script_generations.generate_script.generate_workflow_parameters_schema",+ new_callable=AsyncMock,+ return_value=("", {}),+ ),+ patch(+ "skyvern.core.script_generations.generate_script.create_or_update_script_block",+ mock_create_script_block,+ ),+ ):+ result = await generate_workflow_script_python_code(+ file_name="test_nested.py",+ workflow_run_request={"workflow_id": "wpid_test"},+ workflow=workflow,+ blocks=blocks,+ actions_by_task=actions_by_task,+ script_id="script_1",+ script_revision_id="rev_1",+ organization_id="org_1",+ )++ # Must compile+ try:+ ast.parse(result.source_code)+ except SyntaxError as e:+ pytest.fail(f"Generated script has SyntaxError: {e}\n\n{result.source_code}")++ # Verify script blocks created for all three levels+ call_labels = [call.kwargs.get("block_label") for call in mock_create_script_block.call_args_list]+ assert "outer_loop" in call_labels, f"outer for-loop missing. Labels: {call_labels}"+ assert "inner_loop" in call_labels, f"inner for-loop missing. Labels: {call_labels}"+ assert "extract_data" in call_labels, f"inner extraction missing. Labels: {call_labels}"++ @pytest.mark.asyncio+ async def test_nested_forloop_inner_block_gets_cached_function(self) -> None:+ """The extraction block inside a nested for-loop should get a @skyvern.cached function."""+ from skyvern.core.script_generations.generate_script import generate_workflow_script_python_code++ blocks = [+ {+ "block_type": "for_loop",+ "label": "page_loop",+ "loop_variable_reference": "{{ pages }}",+ "workflow_run_block_id": "wfrb_page",+ "loop_blocks": [+ {+ "block_type": "for_loop",+ "label": "doc_loop",+ "loop_variable_reference": "{{ docs }}",+ "workflow_run_block_id": "wfrb_doc",+ "loop_blocks": [+ {+ "block_type": "file_download",+ "label": "download_file",+ "url": "https://example.com",+ "navigation_goal": "Download the file",+ "task_id": "task_download",+ "workflow_run_block_id": "wfrb_download",+ },+ ],+ },+ ],+ },+ ]++ actions_by_task = {+ "task_download": [+ {+ "action_type": "click",+ "action_id": "act_1",+ "xpath": "//a[@class='download']",+ "element_id": "elem_dl",+ "text": None,+ },+ ],+ }++ workflow = {+ "workflow_id": "wf_test",+ "title": "Nested Download Test",+ "workflow_definition": {"parameters": []},+ }++ mock_create_script_block = AsyncMock(return_value=True)++ with (+ patch(+ "skyvern.core.script_generations.generate_script.generate_workflow_parameters_schema",+ new_callable=AsyncMock,+ return_value=("", {}),+ ),+ patch(+ "skyvern.core.script_generations.generate_script.create_or_update_script_block",+ mock_create_script_block,+ ),+ ):+ result = await generate_workflow_script_python_code(+ file_name="test_nested_download.py",+ workflow_run_request={"workflow_id": "wpid_test"},+ workflow=workflow,+ blocks=blocks,+ actions_by_task=actions_by_task,+ script_id="script_1",+ script_revision_id="rev_1",+ organization_id="org_1",+ )++ try:+ ast.parse(result.source_code)+ except SyntaxError as e:+ pytest.fail(f"SyntaxError: {e}\n\n{result.source_code}")++ # Inner block should have a @skyvern.cached function+ assert "@skyvern.cached" in result.source_code+ assert "download_file" in result.source_code++ @pytest.mark.asyncio+ async def test_nested_forloop_labels_tracked_in_processed_labels(self) -> None:+ """Nested for-loop labels should be tracked to avoid duplication+ when preserving unexecuted branch cached blocks."""+ from skyvern.core.script_generations.generate_script import generate_workflow_script_python_code++ blocks = [+ {+ "block_type": "for_loop",+ "label": "outer_loop",+ "loop_variable_reference": "{{ urls }}",+ "workflow_run_block_id": "wfrb_outer",+ "loop_blocks": [+ {+ "block_type": "for_loop",+ "label": "inner_loop",+ "loop_variable_reference": "{{ items }}",+ "workflow_run_block_id": "wfrb_inner",+ "loop_blocks": [+ {+ "block_type": "extraction",+ "label": "deep_extract",+ "data_extraction_goal": "Extract",+ "task_id": "task_deep",+ "workflow_run_block_id": "wfrb_deep",+ },+ ],+ },+ ],+ },+ ]++ actions_by_task = {+ "task_deep": [+ {+ "action_type": "extract",+ "action_id": "a1",+ "xpath": "//div",+ "element_id": "e1",+ "text": None,+ "data_extraction_goal": "Extract",+ },+ ],+ }++ # Also provide the same labels as cached_blocks to test dedup+ mock_cached_extract = MagicMock()+ mock_cached_extract.code = "@skyvern.cached(cache_key='deep_extract')\nasync def deep_extract_fn(): pass"+ mock_cached_extract.run_signature = "await skyvern.extract(prompt='Extract', label='deep_extract')"+ mock_cached_extract.workflow_run_id = "wr_old"+ mock_cached_extract.workflow_run_block_id = "wfrb_old"+ mock_cached_extract.input_fields = None++ mock_cached_loop = MagicMock()+ mock_cached_loop.code = (+ "async for current_value in skyvern.loop(values='{{ items }}', label='inner_loop'): pass"+ )+ mock_cached_loop.run_signature = (+ "async for current_value in skyvern.loop(values='{{ items }}', label='inner_loop'): pass"+ )+ mock_cached_loop.workflow_run_id = "wr_old"+ mock_cached_loop.workflow_run_block_id = "wfrb_old"+ mock_cached_loop.input_fields = None++ workflow = {+ "workflow_id": "wf_test",+ "title": "Dedup Test",+ "workflow_definition": {"parameters": []},+ }++ mock_create_script_block = AsyncMock(return_value=True)++ with (+ patch(+ "skyvern.core.script_generations.generate_script.generate_workflow_parameters_schema",+ new_callable=AsyncMock,+ return_value=("", {}),+ ),+ patch(+ "skyvern.core.script_generations.generate_script.create_or_update_script_block",+ mock_create_script_block,+ ),+ ):+ result = await generate_workflow_script_python_code(+ file_name="test_dedup.py",+ workflow_run_request={"workflow_id": "wpid_test"},+ workflow=workflow,+ blocks=blocks,+ actions_by_task=actions_by_task,+ script_id="s1",+ script_revision_id="r1",+ organization_id="o1",+ cached_blocks={+ "deep_extract": mock_cached_extract,+ "inner_loop": mock_cached_loop,+ },+ )++ try:+ ast.parse(result.source_code)+ except SyntaxError as e:+ pytest.fail(f"SyntaxError: {e}\n\n{result.source_code}")++ # @skyvern.cached should appear exactly once (not duplicated by+ # the "preserve unexecuted branch" section)+ cached_count = result.source_code.count("@skyvern.cached")+ assert cached_count == 1, (+ f"Expected 1 @skyvern.cached but found {cached_count}. "+ f"Nested labels may not be tracked in processed_labels.\n\n{result.source_code}"+ )++ @pytest.mark.asyncio+ async def test_nested_forloop_uses_cached_entry_when_valid(self) -> None:+ """When a nested for-loop has a valid cached entry and is NOT in+ updated_block_labels, create_or_update_script_block should still be+ called (to persist metadata) but use the cached code, not rebuild."""+ from skyvern.core.script_generations.generate_script import generate_workflow_script_python_code++ cached_inner_loop = MagicMock()+ cached_inner_loop.code = (+ "async for current_value in skyvern.loop(values='{{ docs }}', label='inner_loop'):\n pass"+ )+ cached_inner_loop.run_signature = cached_inner_loop.code.strip()+ cached_inner_loop.workflow_run_id = "wr_cached"+ cached_inner_loop.workflow_run_block_id = "wfrb_cached"+ cached_inner_loop.input_fields = None++ cached_deep_extract = MagicMock()+ cached_deep_extract.code = "@skyvern.cached(cache_key='deep_extract')\nasync def deep_extract_fn(page, context):\n await skyvern.extract(prompt='Get data', label='deep_extract')"+ cached_deep_extract.run_signature = "await skyvern.extract(prompt='Get data', label='deep_extract')"+ cached_deep_extract.workflow_run_id = "wr_cached"+ cached_deep_extract.workflow_run_block_id = "wfrb_cached_deep"+ cached_deep_extract.input_fields = None++ blocks = [+ {+ "block_type": "for_loop",+ "label": "outer_loop",+ "loop_variable_reference": "{{ urls }}",+ "workflow_run_block_id": "wfrb_outer",+ "loop_blocks": [+ {+ "block_type": "for_loop",+ "label": "inner_loop",+ "loop_variable_reference": "{{ docs }}",+ "workflow_run_block_id": "wfrb_inner",+ "loop_blocks": [+ {+ "block_type": "extraction",+ "label": "deep_extract",+ "data_extraction_goal": "Get data",+ "task_id": "task_deep",+ "workflow_run_block_id": "wfrb_deep",+ },+ ],+ },+ ],+ },+ ]++ workflow = {+ "workflow_id": "wf_test",+ "title": "Cache Hit Test",+ "workflow_definition": {"parameters": []},+ }++ mock_create_script_block = AsyncMock(return_value=True)++ with (+ patch(+ "skyvern.core.script_generations.generate_script.generate_workflow_parameters_schema",+ new_callable=AsyncMock,+ return_value=("", {}),+ ),+ patch(+ "skyvern.core.script_generations.generate_script.create_or_update_script_block",+ mock_create_script_block,+ ),+ ):+ result = await generate_workflow_script_python_code(+ file_name="test_cache_hit.py",+ workflow_run_request={"workflow_id": "wpid_test"},+ workflow=workflow,+ blocks=blocks,+ actions_by_task={}, # No fresh actions — relying on cache+ script_id="s1",+ script_revision_id="r1",+ organization_id="o1",+ cached_blocks={+ "inner_loop": cached_inner_loop,+ "deep_extract": cached_deep_extract,+ },+ # Neither inner_loop nor its parent outer_loop are in+ # updated_block_labels → should use cached entries.+ updated_block_labels={"__start_block__"},+ )++ try:+ ast.parse(result.source_code)+ except SyntaxError as e:+ pytest.fail(f"SyntaxError: {e}\n\n{result.source_code}")++ # The nested for-loop's cached code should be used+ call_labels = [call.kwargs.get("block_label") for call in mock_create_script_block.call_args_list]+ # inner_loop and deep_extract should both have script_block entries+ assert "inner_loop" in call_labels, f"inner_loop missing from calls: {call_labels}"+ assert "deep_extract" in call_labels, f"deep_extract missing from calls: {call_labels}"++ # The inner_loop call should use the cached code, not freshly built+ inner_loop_call = next(+ c for c in mock_create_script_block.call_args_list if c.kwargs.get("block_label") == "inner_loop"+ )+ assert inner_loop_call.kwargs["block_code"] == cached_inner_loop.code+ assert inner_loop_call.kwargs["workflow_run_id"] == "wr_cached"++ @pytest.mark.asyncio+ async def test_nested_forloop_extraction_url_uses_render_template(self) -> None:+ """Regression: nested extraction with a templated URL (e.g. `{{ outer_loop.current_value.url }}`)+ must be emitted as a `skyvern.render_template("...")` call, not a Python literal.++ This is the follow-up to SKY-8757 surfaced by tests/manual/test_nested_forloop_workflow.py's+ second-run cache-hit check. Without this fix, the cached code ran `await skyvern.extract(...)`+ without a `url=` arg and the fallback `ExtractionBlock(url=None)` hit+ `InvalidWorkflowTaskURLState` at agent.py:200 on every cache hit.+ """+ from skyvern.core.script_generations.generate_script import generate_workflow_script_python_code++ blocks = [+ {+ "block_type": "for_loop",+ "label": "outer_page_loop",+ "loop_variable_reference": "{{ pages }}",+ "workflow_run_block_id": "wfrb_outer",+ "loop_blocks": [+ {+ "block_type": "for_loop",+ "label": "inner_field_loop",+ "loop_variable_reference": "{{ current_value.fields }}",+ "workflow_run_block_id": "wfrb_inner",+ "loop_blocks": [+ {+ "block_type": "extraction",+ "label": "extract_field_data",+ "url": "{{ outer_page_loop.current_value.url }}",+ "data_extraction_goal": "Extract {{ current_value }}.",+ "data_schema": {"type": "object", "properties": {}},+ "task_id": "task_extract",+ "workflow_run_block_id": "wfrb_extract",+ },+ ],+ },+ ],+ },+ ]++ actions_by_task = {+ "task_extract": [+ {+ "action_type": "extract",+ "action_id": "action_1",+ "xpath": "//div",+ "element_id": "elem_1",+ "text": None,+ "data_extraction_goal": "Extract",+ },+ ],+ }++ workflow = {+ "workflow_id": "wf_test",+ "title": "Nested Templated URL Test",+ "workflow_definition": {"parameters": []},+ }++ mock_create_script_block = AsyncMock(return_value=True)++ with (+ patch(+ "skyvern.core.script_generations.generate_script.generate_workflow_parameters_schema",+ new_callable=AsyncMock,+ return_value=("", {}),+ ),+ patch(+ "skyvern.core.script_generations.generate_script.create_or_update_script_block",+ mock_create_script_block,+ ),+ ):+ result = await generate_workflow_script_python_code(+ file_name="test_templated_url.py",+ workflow_run_request={"workflow_id": "wpid_test"},+ workflow=workflow,+ blocks=blocks,+ actions_by_task=actions_by_task,+ script_id="script_1",+ script_revision_id="rev_1",+ organization_id="org_1",+ )++ # Generated code must compile.+ try:+ ast.parse(result.source_code)+ except SyntaxError as e:+ pytest.fail(f"Generated script has SyntaxError: {e}\n\n{result.source_code}")++ # Find the block_code stored for extract_field_data.+ extract_call = next(+ (+ c+ for c in mock_create_script_block.call_args_list+ if c.kwargs.get("block_label") == "extract_field_data"+ ),+ None,+ )+ assert extract_call is not None, (+ "No create_or_update_script_block call for extract_field_data. "+ f"Labels seen: {[c.kwargs.get('block_label') for c in mock_create_script_block.call_args_list]}"+ )+ block_code: str = extract_call.kwargs["block_code"]++ # The URL must be emitted as a skyvern.render_template() call so that+ # {{ outer_page_loop.current_value.url }} resolves at runtime from the+ # workflow_run_context.values populated by skyvern.loop().+ assert "skyvern.render_template" in block_code, (+ f"extract_field_data block_code does not contain skyvern.render_template:\n\n{block_code}"+ )+ assert "{{ outer_page_loop.current_value.url }}" in block_code, (+ f"Template string not present in block_code:\n\n{block_code}"+ )+ # And must NOT appear as a raw Python literal passed to extract(..., url=...).+ assert "url='{{ outer_page_loop.current_value.url }}'" not in block_code, (+ f"URL was emitted as a literal, not a render_template call:\n\n{block_code}"+ )+ assert 'url="{{ outer_page_loop.current_value.url }}"' not in block_code, (+ f"URL was emitted as a literal, not a render_template call:\n\n{block_code}"+ )+++# ---------------------------------------------------------------------------+# Part 3: _render_value unit tests+# ---------------------------------------------------------------------------+class TestRenderValue:+ """Unit tests for the _render_value CST helper in generate_script.py."""++ def test_empty_or_none_returns_valid_cst_node(self) -> None:+ """Empty/None prompts return valid CST nodes that libcst can serialize.++ Regression: the original helper returned `cst.SimpleString("")` which+ libcst rejects because it lacks enclosing quotes. The helper now+ delegates to `_value` for the empty/None case — `_value("")` emits a+ `SimpleString("''")` and `_value(None)` emits `Name("None")`.+ """+ import libcst as cst++ from skyvern.core.script_generations.generate_script import _render_value++ module = cst.Module(body=[])++ result_empty = _render_value("")+ assert isinstance(result_empty, cst.SimpleString)+ assert module.code_for_node(result_empty) == "''"++ # None passes through _value → cst.parse_expression("None") which+ # is a Name node, not a SimpleString, but still a valid BaseExpression.+ result_none = _render_value(None)+ assert module.code_for_node(result_none) == "None"++ def test_plain_string_returns_literal_simple_string(self) -> None:+ """A non-template string falls back to _value() and emits a Python literal."""+ import libcst as cst++ from skyvern.core.script_generations.generate_script import _render_value++ result = _render_value("https://example.com")+ # _value wraps strings via repr() → "'https://example.com'"+ assert isinstance(result, cst.SimpleString)+ assert result.value == "'https://example.com'"++ def test_template_string_emits_render_template_call(self) -> None:+ """A string containing {{...}} is emitted as skyvern.render_template(...) call."""+ import libcst as cst++ from skyvern.core.script_generations.generate_script import _render_value++ result = _render_value("{{ outer_page_loop.current_value.url }}")+ assert isinstance(result, cst.Call)+ # The call should be skyvern.render_template("{{ ... }}")+ module = cst.Module(body=[])+ rendered = module.code_for_node(result)+ assert rendered.startswith("skyvern.render_template(")+ assert '"{{ outer_page_loop.current_value.url }}"' in rendered or (+ "'{{ outer_page_loop.current_value.url }}'" in rendered+ )++ def test_template_string_with_data_variable_appends_kwarg(self) -> None:+ """When a data_variable_name is provided, it is passed as a data= kwarg."""+ import libcst as cst++ from skyvern.core.script_generations.generate_script import _render_value++ result = _render_value("{{ current_value }}", data_variable_name="context_params")+ assert isinstance(result, cst.Call)+ module = cst.Module(body=[])+ rendered = module.code_for_node(result)+ # libcst may emit with or without whitespace around =; accept both.+ assert "data=context_params" in rendered or "data = context_params" in rendered