rappel 0.4.5__py3-none-win_amd64.whl → 0.8.1__py3-none-win_amd64.whl

rappel/ir_builder.py

@@ -5,15 +5,10 @@ This module parses Python workflow classes and produces the IR representation
 that can be sent to the Rust runtime for execution.
 
 The IR builder performs deep transformations to convert Python patterns into
-valid Rappel IR structures. Each control flow body (try, for, if branches)
-should have at most ONE action/function call. When bodies have multiple
-action calls, they are wrapped into synthetic functions.
-
-Transformations:
-1. **Try body wrapping**: Wraps multi-action try bodies into synthetic functions
-2. **For loop body wrapping**: Wraps multi-action for bodies into synthetic functions
-3. **If branch wrapping**: Wraps multi-action if/elif/else branches into synthetic functions
-4. **Exception handler wrapping**: Wraps multi-action handlers into synthetic functions
+valid Rappel IR structures. Control flow bodies (try, for, if branches) are
+represented as full blocks, so they can contain arbitrary statements and
+`return` behaves consistently with Python (returns from the entry function end
+the workflow).
 
 Validation:
 The IR builder proactively detects unsupported Python patterns and raises
@@ -27,9 +22,11 @@ import copy
 import inspect
 import textwrap
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Union
+from enum import EnumMeta
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, NoReturn, Optional, Set, Union
 
 from proto import ast_pb2 as ir
+from rappel.registry import registry
 
 
 class UnsupportedPatternError(Exception):
@@ -45,13 +42,22 @@ class UnsupportedPatternError(Exception):
         recommendation: str,
         line: Optional[int] = None,
         col: Optional[int] = None,
+        filename: Optional[str] = None,
     ):
         self.message = message
         self.recommendation = recommendation
         self.line = line
         self.col = col
-
-        location = f" (line {line})" if line else ""
+        self.filename = filename
+
+        location_parts: List[str] = []
+        if filename:
+            location_parts.append(filename)
+        if line:
+            location_parts.append(f"line {line}")
+        if col is not None:
+            location_parts.append(f"col {col}")
+        location = f" ({', '.join(location_parts)})" if location_parts else ""
         full_message = f"{message}{location}\n\nRecommendation: {recommendation}"
         super().__init__(full_message)
 
@@ -223,8 +229,34 @@ RECOMMENDATIONS = {
         "Yield statements are not supported in workflow code.\n"
         "Workflows must return a complete result, not generate values incrementally."
     ),
+    "continue_statement": (
+        "Continue statements are not supported in workflow code.\n"
+        "Restructure your loop using if/else to skip iterations."
+    ),
+    "unsupported_statement": (
+        "This statement type is not supported in workflow code.\n"
+        "Move the logic into an @action or rewrite using supported statements."
+    ),
+    "unsupported_expression": (
+        "This expression type is not supported in workflow code.\n"
+        "Move the logic into an @action or rewrite using supported expressions."
+    ),
+    "unsupported_literal": (
+        "This literal type is not supported in workflow code.\n"
+        "Convert the value to a supported literal type inside an @action."
+    ),
 }
 
+GLOBAL_FUNCTIONS = {
+    "enumerate": ir.GlobalFunction.GLOBAL_FUNCTION_ENUMERATE,
+    "isexception": ir.GlobalFunction.GLOBAL_FUNCTION_ISEXCEPTION,
+    "len": ir.GlobalFunction.GLOBAL_FUNCTION_LEN,
+    "range": ir.GlobalFunction.GLOBAL_FUNCTION_RANGE,
+}
+ALLOWED_SYNC_FUNCTIONS = set(GLOBAL_FUNCTIONS)
+
+_CURRENT_ACTION_NAMES: set[str] = set()
+
 
 if TYPE_CHECKING:
     from .workflow import Workflow
@@ -239,6 +271,32 @@ class ActionDefinition:
     signature: inspect.Signature
 
 
+@dataclass
+class FunctionParameter:
+    """A function parameter with optional default value."""
+
+    name: str
+    has_default: bool
+    default_value: Any = None  # The actual Python value if has_default is True
+
+
+@dataclass
+class FunctionSignatureInfo:
+    """Signature info for a workflow function, used to fill in default arguments."""
+
+    parameters: List[FunctionParameter]
+
+
+@dataclass
+class ModuleContext:
+    """Cached IRBuilder context derived from a module."""
+
+    action_defs: Dict[str, ActionDefinition]
+    imported_names: Dict[str, "ImportedName"]
+    module_functions: Set[str]
+    model_defs: Dict[str, "ModelDefinition"]
+
+
 @dataclass
 class TransformContext:
     """Context for IR transformations."""
@@ -247,10 +305,14 @@ class TransformContext:
     implicit_fn_counter: int = 0
     # Implicit functions generated during transformation
     implicit_functions: List[ir.FunctionDef] = None  # type: ignore
+    # Function signatures for workflow methods (used to fill in default arguments)
+    function_signatures: Dict[str, FunctionSignatureInfo] = None  # type: ignore
 
     def __post_init__(self) -> None:
         if self.implicit_functions is None:
             self.implicit_functions = []
+        if self.function_signatures is None:
+            self.function_signatures = {}
 
     def next_implicit_fn_name(self, prefix: str = "implicit") -> str:
         """Generate a unique implicit function name."""
@@ -277,41 +339,218 @@ def build_workflow_ir(workflow_cls: type["Workflow"]) -> ir.Program:
     if module is None:
         raise ValueError(f"unable to locate module for workflow {workflow_cls!r}")
 
-    # Get the function source and parse it
-    function_source = textwrap.dedent(inspect.getsource(original_run))
-    tree = ast.parse(function_source)
+    module_contexts: Dict[str, ModuleContext] = {}
 
-    # Discover actions in the module
-    action_defs = _discover_action_names(module)
+    def get_module_context(target_module: Any) -> ModuleContext:
+        module_name = target_module.__name__
+        if module_name not in module_contexts:
+            module_contexts[module_name] = ModuleContext(
+                action_defs=_discover_action_names(target_module),
+                imported_names=_discover_module_imports(target_module),
+                module_functions=_discover_module_functions(target_module),
+                model_defs=_discover_model_definitions(target_module),
+            )
+        return module_contexts[module_name]
 
-    # Discover imports for built-in detection (e.g., from asyncio import sleep)
-    imported_names = _discover_module_imports(module)
+    # Build the IR with transformation context
+    ctx = TransformContext()
+    program = ir.Program()
+    function_defs: Dict[str, ir.FunctionDef] = {}
+
+    # Extract instance attributes from __init__ for policy resolution
+    instance_attrs = _extract_instance_attrs(workflow_cls)
+
+    def parse_function(fn: Any) -> tuple[ast.AST, Optional[str], int]:
+        source_lines, start_line = inspect.getsourcelines(fn)
+        function_source = textwrap.dedent("".join(source_lines))
+        filename = inspect.getsourcefile(fn)
+        if filename is None:
+            filename = inspect.getfile(fn)
+        return ast.parse(function_source, filename=filename or "<unknown>"), filename, start_line
+
+    def _with_source_location(
+        err: UnsupportedPatternError,
+        filename: Optional[str],
+        start_line: int,
+    ) -> UnsupportedPatternError:
+        line = err.line
+        col = err.col
+        if line is not None:
+            line = start_line + line - 1
+        if col is not None:
+            col = col + 1
+        return UnsupportedPatternError(
+            err.message,
+            err.recommendation,
+            line=line,
+            col=col,
+            filename=filename,
+        )
 
-    # Discover all async function names in the module (for non-action detection)
-    module_functions = _discover_module_functions(module)
+    def add_function_def(
+        fn: Any,
+        fn_tree: ast.AST,
+        filename: Optional[str],
+        start_line: int,
+        override_name: Optional[str] = None,
+    ) -> None:
+        global _CURRENT_ACTION_NAMES
+        fn_module = inspect.getmodule(fn)
+        if fn_module is None:
+            raise ValueError(f"unable to locate module for function {fn!r}")
+
+        ctx_data = get_module_context(fn_module)
+        _CURRENT_ACTION_NAMES = set(ctx_data.action_defs.keys())
+        builder = IRBuilder(
+            ctx_data.action_defs,
+            ctx,
+            ctx_data.imported_names,
+            ctx_data.module_functions,
+            ctx_data.model_defs,
+            fn_module.__dict__,
+            instance_attrs,
+        )
+        try:
+            builder.visit(fn_tree)
+        except UnsupportedPatternError as err:
+            raise _with_source_location(err, filename, start_line) from err
+        if builder.function_def:
+            if override_name:
+                builder.function_def.name = override_name
+            function_defs[builder.function_def.name] = builder.function_def
+
+    # Discover all reachable helper methods first so we can pre-collect their signatures.
+    # This is needed because when we process a function that calls another function,
+    # we need to know the callee's signature to fill in default arguments.
+    run_tree, run_filename, run_start_line = parse_function(original_run)
+
+    # Collect all reachable methods and their trees
+    methods_to_process: List[tuple[Any, ast.AST, Optional[str], int, Optional[str]]] = [
+        (original_run, run_tree, run_filename, run_start_line, "main")
+    ]
+    pending = list(_collect_self_method_calls(run_tree))
+    visited: Set[str] = set()
+    skip_methods = {"run_action"}
+
+    while pending:
+        method_name = pending.pop()
+        if method_name in visited or method_name == "run" or method_name in skip_methods:
+            continue
+        visited.add(method_name)
 
-    # Discover Pydantic models and dataclasses that can be used in workflows
-    model_defs = _discover_model_definitions(module)
+        method = _find_workflow_method(workflow_cls, method_name)
+        if method is None:
+            continue
 
-    # Build the IR with transformation context
-    ctx = TransformContext()
-    builder = IRBuilder(action_defs, ctx, imported_names, module_functions, model_defs)
-    builder.visit(tree)
+        method_tree, method_filename, method_start_line = parse_function(method)
+        methods_to_process.append((method, method_tree, method_filename, method_start_line, None))
+        pending.extend(_collect_self_method_calls(method_tree))
+
+    # Pre-collect signatures for all methods before processing IR.
+    # This ensures that when we encounter a function call, we can fill in default args.
+    for fn, _fn_tree, _filename, _start_line, override_name in methods_to_process:
+        fn_name = override_name if override_name else fn.__name__
+        sig = inspect.signature(fn)
+        params: List[FunctionParameter] = []
+        for param_name, param in sig.parameters.items():
+            if param_name == "self":
+                continue
+            has_default = param.default is not inspect.Parameter.empty
+            default_value = param.default if has_default else None
+            params.append(
+                FunctionParameter(
+                    name=param_name,
+                    has_default=has_default,
+                    default_value=default_value,
+                )
+            )
+        ctx.function_signatures[fn_name] = FunctionSignatureInfo(parameters=params)
 
-    # Create the Program with the main function and any implicit functions
-    program = ir.Program()
+    # Now process all functions with signatures already available
+    for fn, fn_tree, filename, start_line, override_name in methods_to_process:
+        add_function_def(fn, fn_tree, filename, start_line, override_name)
 
     # Add implicit functions first (they may be called by the main function)
     for implicit_fn in ctx.implicit_functions:
         program.functions.append(implicit_fn)
 
-    # Add the main function
-    if builder.function_def:
-        program.functions.append(builder.function_def)
+    # Add all function definitions (run + reachable helper methods)
+    for fn_def in function_defs.values():
+        program.functions.append(fn_def)
+
+    global _CURRENT_ACTION_NAMES
+    _CURRENT_ACTION_NAMES = set()
 
     return program
 
 
+def _collect_self_method_calls(tree: ast.AST) -> Set[str]:
+    """Collect self.method(...) call names from a parsed function AST."""
+    calls: Set[str] = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        if isinstance(func, ast.Attribute) and isinstance(func.value, ast.Name):
+            if func.value.id == "self":
+                calls.add(func.attr)
+    return calls
+
+
+def _find_workflow_method(workflow_cls: type["Workflow"], name: str) -> Optional[Any]:
+    """Find a workflow method by name across the class MRO."""
+    for base in workflow_cls.__mro__:
+        if name not in base.__dict__:
+            continue
+        value = base.__dict__[name]
+        if isinstance(value, staticmethod) or isinstance(value, classmethod):
+            return value.__func__
+        if inspect.isfunction(value):
+            return value
+    return None
+
+
+def _extract_instance_attrs(workflow_cls: type["Workflow"]) -> Dict[str, ast.expr]:
+    """Extract self.attr = value assignments from the workflow's __init__ method.
+
+    Parses the __init__ method to find assignments like:
+        self.retry_policy = RetryPolicy(attempts=3)
+        self.timeout = 30
+
+    Returns a dict mapping attribute names to their AST value nodes.
+    """
+    init_method = _find_workflow_method(workflow_cls, "__init__")
+    if init_method is None:
+        return {}
+
+    try:
+        source_lines, _ = inspect.getsourcelines(init_method)
+        source = textwrap.dedent("".join(source_lines))
+        tree = ast.parse(source)
+    except (OSError, TypeError, SyntaxError):
+        return {}
+
+    attrs: Dict[str, ast.expr] = {}
+
+    # Walk the __init__ body looking for self.attr = value assignments
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Assign):
+            continue
+        # Only handle single-target assignments
+        if len(node.targets) != 1:
+            continue
+        target = node.targets[0]
+        # Check for self.attr pattern
+        if (
+            isinstance(target, ast.Attribute)
+            and isinstance(target.value, ast.Name)
+            and target.value.id == "self"
+        ):
+            attrs[target.attr] = node.value
+
+    return attrs
+
+
 def _discover_action_names(module: Any) -> Dict[str, ActionDefinition]:
     """Discover all @action decorated functions in a module."""
     names: Dict[str, ActionDefinition] = {}
@@ -326,6 +565,18 @@ def _discover_action_names(module: Any) -> Dict[str, ActionDefinition]:
                 module_name=action_module or module.__name__,
                 signature=signature,
             )
+    for entry in registry.entries():
+        if entry.module != module.__name__:
+            continue
+        func_name = entry.func.__name__
+        if func_name in names:
+            continue
+        signature = inspect.signature(entry.func)
+        names[func_name] = ActionDefinition(
+            action_name=entry.name,
+            module_name=entry.module,
+            signature=signature,
+        )
     return names
 
 
@@ -592,21 +843,22 @@ class IRBuilder(ast.NodeVisitor):
         imported_names: Optional[Dict[str, ImportedName]] = None,
         module_functions: Optional[Set[str]] = None,
         model_defs: Optional[Dict[str, ModelDefinition]] = None,
+        module_globals: Optional[Mapping[str, Any]] = None,
+        instance_attrs: Optional[Dict[str, ast.expr]] = None,
     ):
         self._action_defs = action_defs
         self._ctx = ctx
         self._imported_names = imported_names or {}
         self._module_functions = module_functions or set()
         self._model_defs = model_defs or {}
+        self._module_globals = module_globals or {}
+        self._instance_attrs = instance_attrs or {}
         self.function_def: Optional[ir.FunctionDef] = None
         self._statements: List[ir.Statement] = []
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
         """Visit a function definition (the workflow's run method)."""
-        # Extract inputs from function parameters (skip 'self')
-        inputs: List[str] = []
-        for arg in node.args.args[1:]:  # Skip 'self'
-            inputs.append(arg.arg)
+        inputs = self._collect_function_inputs(node)
 
         # Create the function definition
         self.function_def = ir.FunctionDef(
@@ -627,9 +879,7 @@ class IRBuilder(ast.NodeVisitor):
     def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:
         """Visit an async function definition (the workflow's run method)."""
         # Handle async the same way as sync for IR building
-        inputs: List[str] = []
-        for arg in node.args.args[1:]:  # Skip 'self'
-            inputs.append(arg.arg)
+        inputs = self._collect_function_inputs(node)
 
         self.function_def = ir.FunctionDef(
             name=node.name,
@@ -661,32 +911,42 @@ class IRBuilder(ast.NodeVisitor):
                 return expanded
             result = self._visit_assign(node)
             return [result] if result else []
+        elif isinstance(node, ast.AnnAssign):
+            result = self._visit_ann_assign(node)
+            return [result] if result else []
         elif isinstance(node, ast.Expr):
             result = self._visit_expr_stmt(node)
             return [result] if result else []
         elif isinstance(node, ast.For):
             return self._visit_for(node)
         elif isinstance(node, ast.If):
-            result = self._visit_if(node)
-            return [result] if result else []
+            return self._visit_if(node)
         elif isinstance(node, ast.Try):
             return self._visit_try(node)
         elif isinstance(node, ast.Return):
             return self._visit_return(node)
         elif isinstance(node, ast.AugAssign):
-            result = self._visit_aug_assign(node)
-            return [result] if result else []
+            return self._visit_aug_assign(node)
         elif isinstance(node, ast.Pass):
             # Pass statements are fine, they just don't produce IR
             return []
+        elif isinstance(node, ast.Break):
+            return self._visit_break(node)
+        elif isinstance(node, ast.Continue):
+            return self._visit_continue(node)
 
-        # Check for unsupported statement types
+        # Check for unsupported statement types - this MUST raise for any
+        # unhandled statement to avoid silently dropping code
         self._check_unsupported_statement(node)
 
-        return []
+    def _check_unsupported_statement(self, node: ast.stmt) -> NoReturn:
+        """Check for unsupported statement types and raise descriptive errors.
 
-    def _check_unsupported_statement(self, node: ast.stmt) -> None:
-        """Check for unsupported statement types and raise descriptive errors."""
+        This function ALWAYS raises an exception - it never returns normally.
+        Any statement type that reaches this function is either explicitly
+        unsupported (with a specific error message) or unhandled (with a
+        generic catch-all error). This ensures we never silently drop code.
+        """
         line = getattr(node, "lineno", None)
         col = getattr(node, "col_offset", None)
 
@@ -767,6 +1027,16 @@ class IRBuilder(ast.NodeVisitor):
                 line=line,
                 col=col,
             )
+        else:
+            # Catch-all for any unhandled statement types.
+            # This is critical to avoid silently dropping code.
+            stmt_type = type(node).__name__
+            raise UnsupportedPatternError(
+                f"Unhandled statement type: {stmt_type}",
+                RECOMMENDATIONS["unsupported_statement"],
+                line=line,
+                col=col,
+            )
 
     def _expand_list_comprehension_assignment(
         self, node: ast.Assign
@@ -985,6 +1255,16 @@ class IRBuilder(ast.NodeVisitor):
 
         return statements
 
+    def _visit_ann_assign(self, node: ast.AnnAssign) -> Optional[ir.Statement]:
+        """Convert annotated assignment to IR when a value is present."""
+        if node.value is None:
+            return None
+
+        assign = ast.Assign(targets=[node.target], value=node.value, type_comment=None)
+        ast.copy_location(assign, node)
+        ast.fix_missing_locations(assign)
+        return self._visit_assign(assign)
+
     def _visit_assign(self, node: ast.Assign) -> Optional[ir.Statement]:
         """Convert assignment to IR.
 
@@ -1038,7 +1318,7 @@ class IRBuilder(ast.NodeVisitor):
             return stmt
 
         # Regular assignment (variables, literals, expressions)
-        value_expr = _expr_to_ir(node.value)
+        value_expr = self._expr_to_ir_with_model_coercion(node.value)
         if value_expr:
             assign = ir.Assignment(targets=targets, value=value_expr)
             stmt.assignment.CopyFrom(assign)
@@ -1090,7 +1370,7 @@ class IRBuilder(ast.NodeVisitor):
                 append_value = call.args[0]
                 # Create: list = list + [value]
                 list_var = ir.Expr(variable=ir.Variable(name=list_name), span=_make_span(node))
-                value_expr = _expr_to_ir(append_value)
+                value_expr = self._expr_to_ir_with_model_coercion(append_value)
                 if value_expr:
                     # Create [value] as a list literal
                     list_literal = ir.Expr(
@@ -1108,7 +1388,7 @@ class IRBuilder(ast.NodeVisitor):
                     return stmt
 
         # Regular expression
-        expr = _expr_to_ir(node.value)
+        expr = self._expr_to_ir_with_model_coercion(node.value)
         if expr:
             stmt.expr_stmt.CopyFrom(ir.ExprStmt(expr=expr))
             return stmt
@@ -1116,34 +1396,10 @@ class IRBuilder(ast.NodeVisitor):
         return None
 
     def _visit_for(self, node: ast.For) -> List[ir.Statement]:
-        """Convert for loop to IR with body wrapping transformation.
-
-        If the for loop body has multiple action/function calls, we wrap them
-        into a synthetic function and replace the body with a single call.
-
-        For loops that modify out-of-scope variables (accumulators) are detected
-        and those variables are set as targets on the SingleCallBody. This enables
-        the runtime to properly aggregate results into those variables.
-
-        Supported accumulator patterns:
-        1. List append: results.append(value)
-        2. Dict subscript: result[key] = value
-        3. List concatenation: results = results + [value]
-        4. Counter increment: count = count + 1
-
-        Python:
-            for item in items:
-                a = await step_one(item)
-                b = await step_two(a)
-
-        Becomes IR equivalent of:
-            fn __for_body_1__(item):
-                a = @step_one(item=item)
-                b = @step_two(a=a)
-                return b
-
-            for item in items:
-                __for_body_1__(item=item)
+        """Convert for loop to IR.
+
+        The loop body is emitted as a full block so it can contain multiple
+        statements/calls and early `return`.
         """
         # Get loop variables
         loop_vars: List[str] = []
@@ -1155,41 +1411,21 @@ class IRBuilder(ast.NodeVisitor):
                     loop_vars.append(elt.id)
 
         # Get iterable
-        iterable = _expr_to_ir(node.iter)
+        iterable = self._expr_to_ir_with_model_coercion(node.iter)
         if not iterable:
             return []
 
-        # Collect variables defined within the loop body (in-scope)
-        in_scope_vars = set(loop_vars)
-
         # Build body statements (recursively transforms nested structures)
         body_stmts: List[ir.Statement] = []
         for body_node in node.body:
             stmts = self._visit_statement(body_node)
             body_stmts.extend(stmts)
-            # Track variables defined by assignments in this iteration
-            for s in stmts:
-                if s.HasField("assignment"):
-                    in_scope_vars.update(s.assignment.targets)
-
-        # Detect all out-of-scope variable modifications
-        # These are variables modified in the loop body but defined outside it
-        modified_vars = self._detect_accumulator_targets(body_stmts, in_scope_vars)
-
-        # ALWAYS wrap for loop body into a synthetic function for variable isolation.
-        # Variables flow in/out explicitly through function parameters and return values.
-        body_stmts = self._wrap_body_as_function(
-            body_stmts, "for_body", node, inputs=loop_vars, modified_vars=modified_vars
-        )
 
-        # Convert to SingleCallBody (now contains just the synthetic function call)
         stmt = ir.Statement(span=_make_span(node))
-        single_call_body = self._stmts_to_single_call_body(body_stmts, _make_span(node))
-
         for_loop = ir.ForLoop(
             loop_vars=loop_vars,
             iterable=iterable,
-            body=single_call_body,
+            block_body=ir.Block(statements=body_stmts, span=_make_span(node)),
         )
         stmt.for_loop.CopyFrom(for_loop)
         return [stmt]
@@ -1223,26 +1459,22 @@ class IRBuilder(ast.NodeVisitor):
             # Check conditionals for accumulator targets in branch bodies
             if stmt.HasField("conditional"):
                 cond = stmt.conditional
-                branch_bodies = [cond.if_branch.body] if cond.HasField("if_branch") else []
-                branch_bodies.extend(
-                    branch.body for branch in cond.elif_branches if branch.HasField("body")
-                )
-                if cond.HasField("else_branch"):
-                    branch_bodies.append(cond.else_branch.body)
-
-                for body in branch_bodies:
-                    for target in body.targets:
-                        if target not in in_scope_vars and target not in seen:
-                            accumulators.append(target)
-                            seen.add(target)
-
-                    if body.statements:
-                        for var in self._detect_accumulator_targets(
-                            list(body.statements), in_scope_vars
-                        ):
-                            if var not in seen:
-                                accumulators.append(var)
-                                seen.add(var)
+                branch_blocks: list[ir.Block] = []
+                if cond.HasField("if_branch") and cond.if_branch.HasField("block_body"):
+                    branch_blocks.append(cond.if_branch.block_body)
+                for branch in cond.elif_branches:
+                    if branch.HasField("block_body"):
+                        branch_blocks.append(branch.block_body)
+                if cond.HasField("else_branch") and cond.else_branch.HasField("block_body"):
+                    branch_blocks.append(cond.else_branch.block_body)
+
+                for block in branch_blocks:
+                    for var in self._detect_accumulator_targets(
+                        list(block.statements), in_scope_vars
+                    ):
+                        if var not in seen:
+                            accumulators.append(var)
+                            seen.add(var)
 
         return accumulators
 
@@ -1316,10 +1548,9 @@ class IRBuilder(ast.NodeVisitor):
             for elem in expr.list.elements:
                 vars_found.update(self._collect_variables_from_expr(elem))
         elif expr.HasField("dict"):
-            for key in expr.dict.keys:
-                vars_found.update(self._collect_variables_from_expr(key))
-            for val in expr.dict.values:
-                vars_found.update(self._collect_variables_from_expr(val))
+            for entry in expr.dict.entries:
+                vars_found.update(self._collect_variables_from_expr(entry.key))
+                vars_found.update(self._collect_variables_from_expr(entry.value))
         elif expr.HasField("index"):
             vars_found.update(self._collect_variables_from_expr(expr.index.value))
             vars_found.update(self._collect_variables_from_expr(expr.index.index))
@@ -1334,112 +1565,143 @@ class IRBuilder(ast.NodeVisitor):
 
         return vars_found
 
-    def _visit_if(self, node: ast.If) -> Optional[ir.Statement]:
-        """Convert if statement to IR conditional with branch wrapping.
+    def _visit_if(self, node: ast.If) -> List[ir.Statement]:
+        """Convert if statement to IR.
 
-        If any branch has multiple action calls, we wrap it into a synthetic
-        function to ensure each branch has at most one call.
+        Normalizes patterns like:
+            if await some_action(...):
+                ...
+        into:
+            __if_cond_n__ = await some_action(...)
+            if __if_cond_n__:
+                ...
+        """
 
-        Out-of-scope variable modifications (like list.append()) are detected
-        and the modified variables are passed in/out of the synthetic function.
+        def normalize_condition(test: ast.expr) -> tuple[List[ir.Statement], Optional[ir.Expr]]:
+            action_call = self._extract_action_call(test)
+            if action_call is None:
+                return ([], self._expr_to_ir_with_model_coercion(test))
 
-        Python:
-            if condition:
-                a = await action_a()
-                b = await action_b(a)
-            else:
-                c = await action_c()
+            if not isinstance(test, ast.Await):
+                line = getattr(test, "lineno", None)
+                col = getattr(test, "col_offset", None)
+                raise UnsupportedPatternError(
+                    "Action calls inside boolean expressions are not supported in if conditions",
+                    "Assign the awaited action result to a variable, then use the variable in the if condition.",
+                    line=line,
+                    col=col,
+                )
 
-        Becomes IR equivalent of:
-            fn __if_then_1__():
-                a = @action_a()
-                b = @action_b(a=a)
-                return b
+            cond_var = self._ctx.next_implicit_fn_name(prefix="if_cond")
+            assign_stmt = ir.Statement(span=_make_span(test))
+            assign_stmt.assignment.CopyFrom(
+                ir.Assignment(
+                    targets=[cond_var],
+                    value=ir.Expr(action_call=action_call, span=_make_span(test)),
+                )
+            )
+            cond_expr = ir.Expr(variable=ir.Variable(name=cond_var), span=_make_span(test))
+            return ([assign_stmt], cond_expr)
 
-            if condition:
-                __if_then_1__()
-            else:
-                @action_c()
-        """
-        stmt = ir.Statement(span=_make_span(node))
+        def visit_body(nodes: list[ast.stmt]) -> List[ir.Statement]:
+            stmts: List[ir.Statement] = []
+            for body_node in nodes:
+                stmts.extend(self._visit_statement(body_node))
+            return stmts
 
-        # Build if branch
-        condition = _expr_to_ir(node.test)
-        if not condition:
-            return None
+        # Collect if/elif branches as (test_expr, body_nodes)
+        branches: list[tuple[ast.expr, list[ast.stmt], ast.AST]] = [(node.test, node.body, node)]
+        current = node
+        while current.orelse and len(current.orelse) == 1 and isinstance(current.orelse[0], ast.If):
+            elif_node = current.orelse[0]
+            branches.append((elif_node.test, elif_node.body, elif_node))
+            current = elif_node
+
+        else_nodes = current.orelse
+
+        normalized: list[
+            tuple[List[ir.Statement], Optional[ir.Expr], List[ir.Statement], ast.AST]
+        ] = []
+        for test_expr, body_nodes, span_node in branches:
+            prefix, cond = normalize_condition(test_expr)
+            normalized.append((prefix, cond, visit_body(body_nodes), span_node))
+
+        else_body = visit_body(else_nodes) if else_nodes else []
+
+        # If any non-first branch needs normalization, preserve Python semantics by nesting.
+        requires_nested = any(prefix for prefix, _, _, _ in normalized[1:])
+
+        def build_conditional_stmt(
+            condition: ir.Expr,
+            then_body: List[ir.Statement],
+            else_body_statements: List[ir.Statement],
+            span_node: ast.AST,
+        ) -> ir.Statement:
+            conditional_stmt = ir.Statement(span=_make_span(span_node))
+            if_branch = ir.IfBranch(
+                condition=condition,
+                block_body=ir.Block(statements=then_body, span=_make_span(span_node)),
+                span=_make_span(span_node),
+            )
+            conditional = ir.Conditional(if_branch=if_branch)
+            if else_body_statements:
+                else_branch = ir.ElseBranch(
+                    block_body=ir.Block(
+                        statements=else_body_statements,
+                        span=_make_span(span_node),
+                    ),
+                    span=_make_span(span_node),
+                )
+                conditional.else_branch.CopyFrom(else_branch)
+            conditional_stmt.conditional.CopyFrom(conditional)
+            return conditional_stmt
 
-        body_stmts: List[ir.Statement] = []
-        for body_node in node.body:
-            stmts = self._visit_statement(body_node)
-            body_stmts.extend(stmts)
+        if requires_nested:
+            nested_else: List[ir.Statement] = else_body
+            for prefix, cond, then_body, span_node in reversed(normalized):
+                if cond is None:
+                    continue
+                nested_if_stmt = build_conditional_stmt(
+                    condition=cond,
+                    then_body=then_body,
+                    else_body_statements=nested_else,
+                    span_node=span_node,
+                )
+                nested_else = [*prefix, nested_if_stmt]
+            return nested_else
 
-        # ALWAYS wrap if branch body for variable isolation
-        in_scope_vars = self._collect_assigned_vars(body_stmts)
-        modified_vars = self._detect_accumulator_targets(body_stmts, in_scope_vars)
-        body_stmts = self._wrap_body_as_function(
-            body_stmts, "if_then", node, modified_vars=modified_vars
-        )
+        # Flat conditional with elif/else (original behavior), plus optional prefix for the if guard.
+        if_prefix, if_condition, if_body, if_span_node = normalized[0]
+        if if_condition is None:
+            return []
 
+        conditional_stmt = ir.Statement(span=_make_span(if_span_node))
         if_branch = ir.IfBranch(
-            condition=condition,
-            body=self._stmts_to_single_call_body(body_stmts, _make_span(node)),
-            span=_make_span(node),
+            condition=if_condition,
+            block_body=ir.Block(statements=if_body, span=_make_span(if_span_node)),
+            span=_make_span(if_span_node),
         )
-
         conditional = ir.Conditional(if_branch=if_branch)
 
-        # Handle elif/else chains
-        current = node
-        while current.orelse:
-            if len(current.orelse) == 1 and isinstance(current.orelse[0], ast.If):
-                # elif branch
-                elif_node = current.orelse[0]
-                elif_condition = _expr_to_ir(elif_node.test)
-                if elif_condition:
-                    elif_body: List[ir.Statement] = []
-                    for body_node in elif_node.body:
-                        stmts = self._visit_statement(body_node)
-                        elif_body.extend(stmts)
-
-                    # ALWAYS wrap elif body for variable isolation
-                    in_scope_vars = self._collect_assigned_vars(elif_body)
-                    modified_vars = self._detect_accumulator_targets(elif_body, in_scope_vars)
-                    elif_body = self._wrap_body_as_function(
-                        elif_body, "if_elif", elif_node, modified_vars=modified_vars
-                    )
-
-                    elif_branch = ir.ElifBranch(
-                        condition=elif_condition,
-                        body=self._stmts_to_single_call_body(elif_body, _make_span(elif_node)),
-                        span=_make_span(elif_node),
-                    )
-                    conditional.elif_branches.append(elif_branch)
-                current = elif_node
-            else:
-                # else branch
-                else_body: List[ir.Statement] = []
-                for else_node in current.orelse:
-                    stmts = self._visit_statement(else_node)
-                    else_body.extend(stmts)
-
-                # ALWAYS wrap else body for variable isolation
-                in_scope_vars = self._collect_assigned_vars(else_body)
-                modified_vars = self._detect_accumulator_targets(else_body, in_scope_vars)
-                else_body = self._wrap_body_as_function(
-                    else_body, "if_else", current.orelse[0], modified_vars=modified_vars
-                )
+        for _, elif_condition, elif_body, elif_span_node in normalized[1:]:
+            if elif_condition is None:
+                continue
+            elif_branch = ir.ElifBranch(
+                condition=elif_condition,
+                block_body=ir.Block(statements=elif_body, span=_make_span(elif_span_node)),
+                span=_make_span(elif_span_node),
+            )
+            conditional.elif_branches.append(elif_branch)
 
-                else_branch = ir.ElseBranch(
-                    body=self._stmts_to_single_call_body(
-                        else_body, _make_span(current.orelse[0]) if current.orelse else ir.Span()
-                    ),
-                    span=_make_span(current.orelse[0]) if current.orelse else None,
-                )
-                conditional.else_branch.CopyFrom(else_branch)
-                break
+        if else_body:
+            else_branch = ir.ElseBranch(
+                block_body=ir.Block(statements=else_body, span=_make_span(if_span_node)),
+                span=_make_span(if_span_node),
+            )
+            conditional.else_branch.CopyFrom(else_branch)
 
-        stmt.conditional.CopyFrom(conditional)
-        return stmt
+        conditional_stmt.conditional.CopyFrom(conditional)
+        return [*if_prefix, conditional_stmt]
 
     def _collect_assigned_vars(self, stmts: List[ir.Statement]) -> set:
         """Collect all variable names assigned in a list of statements."""
@@ -1463,48 +1725,48 @@ class IRBuilder(ast.NodeVisitor):
 
             if stmt.HasField("conditional"):
                 cond = stmt.conditional
-                if cond.HasField("if_branch") and cond.if_branch.HasField("body"):
+                if cond.HasField("if_branch") and cond.if_branch.HasField("block_body"):
                     for target in self._collect_assigned_vars_in_order(
-                        list(cond.if_branch.body.statements)
+                        list(cond.if_branch.block_body.statements)
                     ):
                         if target not in seen:
                             seen.add(target)
                             assigned.append(target)
                 for elif_branch in cond.elif_branches:
-                    if elif_branch.HasField("body"):
+                    if elif_branch.HasField("block_body"):
                         for target in self._collect_assigned_vars_in_order(
-                            list(elif_branch.body.statements)
+                            list(elif_branch.block_body.statements)
                         ):
                             if target not in seen:
                                 seen.add(target)
                                 assigned.append(target)
-                if cond.HasField("else_branch") and cond.else_branch.HasField("body"):
+                if cond.HasField("else_branch") and cond.else_branch.HasField("block_body"):
                     for target in self._collect_assigned_vars_in_order(
-                        list(cond.else_branch.body.statements)
+                        list(cond.else_branch.block_body.statements)
                     ):
                         if target not in seen:
                             seen.add(target)
                             assigned.append(target)
 
-            if stmt.HasField("for_loop") and stmt.for_loop.HasField("body"):
+            if stmt.HasField("for_loop") and stmt.for_loop.HasField("block_body"):
                 for target in self._collect_assigned_vars_in_order(
-                    list(stmt.for_loop.body.statements)
+                    list(stmt.for_loop.block_body.statements)
                 ):
                     if target not in seen:
                         seen.add(target)
                         assigned.append(target)
 
             if stmt.HasField("try_except"):
-                try_body = stmt.try_except.try_body
-                if try_body.HasField("span"):
-                    for target in self._collect_assigned_vars_in_order(list(try_body.statements)):
+                try_block = stmt.try_except.try_block
+                if try_block.HasField("span"):
+                    for target in self._collect_assigned_vars_in_order(list(try_block.statements)):
                         if target not in seen:
                             seen.add(target)
                             assigned.append(target)
                 for handler in stmt.try_except.handlers:
-                    if handler.HasField("body"):
+                    if handler.HasField("block_body"):
                         for target in self._collect_assigned_vars_in_order(
-                            list(handler.body.statements)
+                            list(handler.block_body.statements)
                         ):
                             if target not in seen:
                                 seen.add(target)
@@ -1512,32 +1774,8 @@ class IRBuilder(ast.NodeVisitor):
 
         return assigned
 
-    def _collect_variables_from_single_call_body(self, body: ir.SingleCallBody) -> list[str]:
-        vars_found: list[str] = []
-        seen: set[str] = set()
-
-        if body.HasField("call"):
-            call = body.call
-            if call.HasField("action"):
-                for kwarg in call.action.kwargs:
-                    for var in self._collect_variables_from_expr(kwarg.value):
-                        if var not in seen:
-                            seen.add(var)
-                            vars_found.append(var)
-            elif call.HasField("function"):
-                for kwarg in call.function.kwargs:
-                    for var in self._collect_variables_from_expr(kwarg.value):
-                        if var not in seen:
-                            seen.add(var)
-                            vars_found.append(var)
-
-        for stmt in body.statements:
-            for var in self._collect_variables_from_statements([stmt]):
-                if var not in seen:
-                    seen.add(var)
-                    vars_found.append(var)
-
-        return vars_found
+    def _collect_variables_from_block(self, block: ir.Block) -> list[str]:
+        return self._collect_variables_from_statements(list(block.statements))
 
     def _collect_variables_from_statements(self, stmts: List[ir.Statement]) -> list[str]:
         """Collect variable references from statements in encounter order."""
@@ -1578,10 +1816,8 @@ class IRBuilder(ast.NodeVisitor):
                             if var not in seen:
                                 seen.add(var)
                                 vars_found.append(var)
-                    if cond.if_branch.HasField("body"):
-                        for var in self._collect_variables_from_single_call_body(
-                            cond.if_branch.body
-                        ):
+                    if cond.if_branch.HasField("block_body"):
+                        for var in self._collect_variables_from_block(cond.if_branch.block_body):
                             if var not in seen:
                                 seen.add(var)
                                 vars_found.append(var)
@@ -1591,13 +1827,13 @@ class IRBuilder(ast.NodeVisitor):
                             if var not in seen:
                                 seen.add(var)
                                 vars_found.append(var)
-                    if elif_branch.HasField("body"):
-                        for var in self._collect_variables_from_single_call_body(elif_branch.body):
+                    if elif_branch.HasField("block_body"):
+                        for var in self._collect_variables_from_block(elif_branch.block_body):
                             if var not in seen:
                                 seen.add(var)
                                 vars_found.append(var)
-                if cond.HasField("else_branch") and cond.else_branch.HasField("body"):
-                    for var in self._collect_variables_from_single_call_body(cond.else_branch.body):
+                if cond.HasField("else_branch") and cond.else_branch.HasField("block_body"):
+                    for var in self._collect_variables_from_block(cond.else_branch.block_body):
                         if var not in seen:
                             seen.add(var)
                             vars_found.append(var)
@@ -1609,22 +1845,22 @@ class IRBuilder(ast.NodeVisitor):
                         if var not in seen:
                             seen.add(var)
                             vars_found.append(var)
-                if fl.HasField("body"):
-                    for var in self._collect_variables_from_single_call_body(fl.body):
+                if fl.HasField("block_body"):
+                    for var in self._collect_variables_from_block(fl.block_body):
                         if var not in seen:
                             seen.add(var)
                             vars_found.append(var)
 
             if stmt.HasField("try_except"):
                 te = stmt.try_except
-                if te.HasField("try_body"):
-                    for var in self._collect_variables_from_single_call_body(te.try_body):
+                if te.HasField("try_block"):
+                    for var in self._collect_variables_from_block(te.try_block):
                         if var not in seen:
                             seen.add(var)
                             vars_found.append(var)
                 for handler in te.handlers:
-                    if handler.HasField("body"):
-                        for var in self._collect_variables_from_single_call_body(handler.body):
+                    if handler.HasField("block_body"):
+                        for var in self._collect_variables_from_block(handler.block_body):
                             if var not in seen:
                                 seen.add(var)
                                 vars_found.append(var)
@@ -1661,66 +1897,13 @@ class IRBuilder(ast.NodeVisitor):
         return vars_found
 
     def _visit_try(self, node: ast.Try) -> List[ir.Statement]:
-        """Convert try/except to IR with body wrapping transformation.
-
-        If the try body has multiple action calls, we wrap the entire body
-        into a synthetic function, preserving exact semantics.
-
-        Python:
-            try:
-                a = await setup_action()
-                b = await risky_action(a)
-                return f"success:{b}"
-            except SomeError:
-                ...
-
-        Becomes IR equivalent of:
-            fn __try_body_1__():
-                a = @setup_action()
-                b = @risky_action(a=a)
-                return f"success:{b}"
-
-            try:
-                __try_body_1__()
-            except SomeError:
-                ...
-        """
+        """Convert try/except to IR with full block bodies."""
         # Build try body statements (recursively transforms nested structures)
         try_body: List[ir.Statement] = []
         for body_node in node.body:
             stmts = self._visit_statement(body_node)
             try_body.extend(stmts)
 
-        # ALWAYS wrap try body for variable isolation
-        assigned_vars_ordered = self._collect_assigned_vars_in_order(try_body)
-        assigned_vars_set = set(assigned_vars_ordered)
-        free_vars = [
-            var
-            for var in self._collect_variables_from_statements(try_body)
-            if var not in assigned_vars_set
-        ]
-        modified_vars = self._detect_accumulator_targets(try_body, assigned_vars_set)
-
-        # Inputs need free variables plus any accumulator-style mutations.
-        try_inputs = []
-        for var in free_vars + modified_vars:
-            if var not in try_inputs:
-                try_inputs.append(var)
-
-        # Outputs include all assigned variables plus accumulator targets.
-        try_outputs: list[str] = []
-        for var in assigned_vars_ordered + modified_vars:
-            if var not in try_outputs:
-                try_outputs.append(var)
-
-        try_body = self._wrap_body_as_function(
-            try_body,
-            "try_body",
-            node,
-            inputs=try_inputs,
-            modified_vars=try_outputs,
-        )
-
         # Build exception handlers (with wrapping if needed)
         handlers: List[ir.ExceptHandler] = []
         for handler in node.handlers:
@@ -1739,46 +1922,20 @@ class IRBuilder(ast.NodeVisitor):
                 stmts = self._visit_statement(handler_node)
                 handler_body.extend(stmts)
 
-            # ALWAYS wrap handler body for variable isolation
-            assigned_vars_ordered = self._collect_assigned_vars_in_order(handler_body)
-            assigned_vars_set = set(assigned_vars_ordered)
-            free_vars = [
-                var
-                for var in self._collect_variables_from_statements(handler_body)
-                if var not in assigned_vars_set
-            ]
-            modified_vars = self._detect_accumulator_targets(handler_body, assigned_vars_set)
-
-            handler_inputs: list[str] = []
-            for var in free_vars + modified_vars:
-                if var not in handler_inputs:
-                    handler_inputs.append(var)
-
-            handler_outputs: list[str] = []
-            for var in assigned_vars_ordered + modified_vars:
-                if var not in handler_outputs:
-                    handler_outputs.append(var)
-
-            handler_body = self._wrap_body_as_function(
-                handler_body,
-                "except_handler",
-                node,
-                inputs=handler_inputs,
-                modified_vars=handler_outputs,
-            )
-
             except_handler = ir.ExceptHandler(
                 exception_types=exception_types,
-                body=self._stmts_to_single_call_body(handler_body, _make_span(handler)),
+                block_body=ir.Block(statements=handler_body, span=_make_span(handler)),
                 span=_make_span(handler),
             )
+            if handler.name:
+                except_handler.exception_var = handler.name
             handlers.append(except_handler)
 
         # Build the try/except statement
         try_stmt = ir.Statement(span=_make_span(node))
         try_except = ir.TryExcept(
-            try_body=self._stmts_to_single_call_body(try_body, _make_span(node)),
             handlers=handlers,
+            try_block=ir.Block(statements=try_body, span=_make_span(node)),
         )
         try_stmt.try_except.CopyFrom(try_except)
 
@@ -1806,56 +1963,6 @@ class IRBuilder(ast.NodeVisitor):
                     count += 1
         return count
 
-    def _stmts_to_single_call_body(
-        self, stmts: List[ir.Statement], span: ir.Span
-    ) -> ir.SingleCallBody:
-        """Convert statements to SingleCallBody.
-
-        Can contain EITHER:
-        1. A single action or function call (with optional target)
-        2. Pure data statements (no calls)
-        """
-        body = ir.SingleCallBody(span=span)
-
-        # Look for a single call in the statements
-        for stmt in stmts:
-            if stmt.HasField("action_call"):
-                # ActionCall as a statement has no target (side-effect only)
-                action = stmt.action_call
-                call = ir.Call()
-                call.action.CopyFrom(action)
-                body.call.CopyFrom(call)
-                return body
-            elif stmt.HasField("assignment"):
-                # Check if assignment value is an action call or function call
-                if stmt.assignment.value.HasField("action_call"):
-                    action = stmt.assignment.value.action_call
-                    # Copy all targets for tuple unpacking support
-                    body.targets.extend(stmt.assignment.targets)
-                    call = ir.Call()
-                    call.action.CopyFrom(action)
-                    body.call.CopyFrom(call)
-                    return body
-                elif stmt.assignment.value.HasField("function_call"):
-                    fn_call = stmt.assignment.value.function_call
-                    # Copy all targets for tuple unpacking support
-                    body.targets.extend(stmt.assignment.targets)
-                    call = ir.Call()
-                    call.function.CopyFrom(fn_call)
-                    body.call.CopyFrom(call)
-                    return body
-            elif stmt.HasField("expr_stmt") and stmt.expr_stmt.expr.HasField("function_call"):
-                fn_call = stmt.expr_stmt.expr.function_call
-                call = ir.Call()
-                call.function.CopyFrom(fn_call)
-                body.call.CopyFrom(call)
-                return body
-
-        # No call found - this is a pure data body
-        # Add all statements as pure data
-        body.statements.extend(stmts)
-        return body
-
     def _wrap_body_as_function(
         self,
         body: List[ir.Statement],
@@ -1976,8 +2083,20 @@ class IRBuilder(ast.NodeVisitor):
 
                 return [assign_stmt, return_stmt]
 
+            # Normalize return of function calls into assignment + return
+            expr = self._expr_to_ir_with_model_coercion(node.value)
+            if expr and expr.HasField("function_call"):
+                tmp_var = self._ctx.next_implicit_fn_name(prefix="return_tmp")
+
+                assign_stmt = ir.Statement(span=_make_span(node))
+                assign_stmt.assignment.CopyFrom(ir.Assignment(targets=[tmp_var], value=expr))
+
+                return_stmt = ir.Statement(span=_make_span(node))
+                var_expr = ir.Expr(variable=ir.Variable(name=tmp_var), span=_make_span(node))
+                return_stmt.return_stmt.CopyFrom(ir.ReturnStmt(value=var_expr))
+                return [assign_stmt, return_stmt]
+
             # Regular return with expression (variable, literal, etc.)
-            expr = _expr_to_ir(node.value)
             if expr:
                 stmt = ir.Statement(span=_make_span(node))
                 return_stmt = ir.ReturnStmt(value=expr)
@@ -1989,7 +2108,19 @@ class IRBuilder(ast.NodeVisitor):
         stmt.return_stmt.CopyFrom(ir.ReturnStmt())
         return [stmt]
 
-    def _visit_aug_assign(self, node: ast.AugAssign) -> Optional[ir.Statement]:
+    def _visit_break(self, node: ast.Break) -> List[ir.Statement]:
+        """Convert break statement to IR."""
+        stmt = ir.Statement(span=_make_span(node))
+        stmt.break_stmt.CopyFrom(ir.BreakStmt())
+        return [stmt]
+
+    def _visit_continue(self, node: ast.Continue) -> List[ir.Statement]:
+        """Convert continue statement to IR."""
+        stmt = ir.Statement(span=_make_span(node))
+        stmt.continue_stmt.CopyFrom(ir.ContinueStmt())
+        return [stmt]
+
+    def _visit_aug_assign(self, node: ast.AugAssign) -> List[ir.Statement]:
         """Convert augmented assignment (+=, -=, etc.) to IR."""
         # For now, we can represent this as a regular assignment with binary op
         # target op= value  ->  target = target op value
@@ -1999,8 +2130,33 @@ class IRBuilder(ast.NodeVisitor):
         if isinstance(node.target, ast.Name):
             targets.append(node.target.id)
 
-        left = _expr_to_ir(node.target)
-        right = _expr_to_ir(node.value)
+        left = self._expr_to_ir_with_model_coercion(node.target)
+        right = self._expr_to_ir_with_model_coercion(node.value)
+        if right and right.HasField("function_call"):
+            tmp_var = self._ctx.next_implicit_fn_name(prefix="aug_tmp")
+
+            assign_tmp = ir.Statement(span=_make_span(node))
+            assign_tmp.assignment.CopyFrom(
+                ir.Assignment(
+                    targets=[tmp_var],
+                    value=ir.Expr(function_call=right.function_call, span=_make_span(node)),
+                )
+            )
+
+            if left:
+                op = _bin_op_to_ir(node.op)
+                if op:
+                    binary = ir.BinaryOp(
+                        left=left,
+                        op=op,
+                        right=ir.Expr(variable=ir.Variable(name=tmp_var)),
+                    )
+                    value = ir.Expr(binary_op=binary)
+                    assign = ir.Assignment(targets=targets, value=value)
+                    stmt.assignment.CopyFrom(assign)
+                    return [assign_tmp, stmt]
+            return [assign_tmp]
+
         if left and right:
             op = _bin_op_to_ir(node.op)
             if op:
@@ -2008,9 +2164,38 @@ class IRBuilder(ast.NodeVisitor):
                 value = ir.Expr(binary_op=binary)
                 assign = ir.Assignment(targets=targets, value=value)
                 stmt.assignment.CopyFrom(assign)
-                return stmt
+                return [stmt]
 
-        return None
+        return []
+
+    def _collect_function_inputs(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> List[str]:
+        """Collect workflow inputs from function parameters, including kw-only args."""
+        args: List[str] = []
+        seen: set[str] = set()
+
+        ordered_args = list(node.args.posonlyargs) + list(node.args.args)
+        if ordered_args and ordered_args[0].arg == "self":
+            ordered_args = ordered_args[1:]
+
+        for arg in ordered_args:
+            if arg.arg not in seen:
+                args.append(arg.arg)
+                seen.add(arg.arg)
+
+        if node.args.vararg and node.args.vararg.arg not in seen:
+            args.append(node.args.vararg.arg)
+            seen.add(node.args.vararg.arg)
+
+        for arg in node.args.kwonlyargs:
+            if arg.arg not in seen:
+                args.append(arg.arg)
+                seen.add(arg.arg)
+
+        if node.args.kwarg and node.args.kwarg.arg not in seen:
+            args.append(node.args.kwarg.arg)
+            seen.add(node.args.kwarg.arg)
+
+        return args
 
     def _check_constructor_in_return(self, node: ast.expr) -> None:
         """Check for constructor calls in return statements.
@@ -2155,7 +2340,7 @@ class IRBuilder(ast.NodeVisitor):
             key_literal.string_value = kw.arg
             key_expr.literal.CopyFrom(key_literal)
 
-            value_expr = _expr_to_ir(kw.value)
+            value_expr = self._expr_to_ir_with_model_coercion(kw.value)
             if value_expr is None:
                 # If we can't convert the value, we need to raise an error
                 line = getattr(node, "lineno", None)
@@ -2192,7 +2377,7 @@ class IRBuilder(ast.NodeVisitor):
                 key_literal.string_value = field_name
                 key_expr.literal.CopyFrom(key_literal)
 
-                value_expr = _expr_to_ir(arg)
+                value_expr = self._expr_to_ir_with_model_coercion(arg)
                 if value_expr is None:
                     line = getattr(node, "lineno", None)
                     col = getattr(node, "col_offset", None)
@@ -2410,7 +2595,19 @@ class IRBuilder(ast.NodeVisitor):
         - RetryPolicy(attempts=3)
         - RetryPolicy(attempts=3, exception_types=["ValueError"])
         - RetryPolicy(attempts=3, backoff_seconds=5)
+        - self.retry_policy (instance attribute reference)
         """
+        # Handle self.attr pattern - look up in instance attrs
+        if (
+            isinstance(node, ast.Attribute)
+            and isinstance(node.value, ast.Name)
+            and node.value.id == "self"
+        ):
+            attr_name = node.attr
+            if attr_name in self._instance_attrs:
+                return self._parse_retry_policy(self._instance_attrs[attr_name])
+            return None
+
         if not isinstance(node, ast.Call):
             return None
 
@@ -2428,7 +2625,9 @@ class IRBuilder(ast.NodeVisitor):
 
         for kw in node.keywords:
             if kw.arg == "attempts" and isinstance(kw.value, ast.Constant):
-                policy.max_retries = kw.value.value
+                # attempts means total executions, max_retries means retries after first attempt
+                # So attempts=1 -> max_retries=0 (no retries), attempts=3 -> max_retries=2
+                policy.max_retries = kw.value.value - 1
             elif kw.arg == "exception_types" and isinstance(kw.value, ast.List):
                 for elt in kw.value.elts:
                     if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
@@ -2446,7 +2645,19 @@ class IRBuilder(ast.NodeVisitor):
         - timeout=30.5 (float seconds)
         - timeout=timedelta(seconds=30)
         - timeout=timedelta(minutes=2)
+        - self.timeout (instance attribute reference)
         """
+        # Handle self.attr pattern - look up in instance attrs
+        if (
+            isinstance(node, ast.Attribute)
+            and isinstance(node.value, ast.Name)
+            and node.value.id == "self"
+        ):
+            attr_name = node.attr
+            if attr_name in self._instance_attrs:
+                return self._parse_timeout_policy(self._instance_attrs[attr_name])
+            return None
+
         policy = ir.TimeoutPolicy()
 
         # Direct numeric value (seconds)
@@ -2511,14 +2722,14 @@ class IRBuilder(ast.NodeVisitor):
         # Extract duration argument (positional or keyword)
         if node.args:
             # asyncio.sleep(1) - positional
-            expr = _expr_to_ir(node.args[0])
+            expr = self._expr_to_ir_with_model_coercion(node.args[0])
             if expr:
                 action_call.kwargs.append(ir.Kwarg(name="duration", value=expr))
         elif node.keywords:
             # asyncio.sleep(seconds=1) - keyword (less common)
             for kw in node.keywords:
                 if kw.arg in ("seconds", "delay", "duration"):
-                    expr = _expr_to_ir(kw.value)
+                    expr = self._expr_to_ir_with_model_coercion(kw.value)
                     if expr:
                         action_call.kwargs.append(ir.Kwarg(name="duration", value=expr))
                     break
@@ -2606,9 +2817,10 @@ class IRBuilder(ast.NodeVisitor):
 
         Handles patterns like:
             [action(x=item) for item in collection]
+            [self.run_action(action(x=item), retry=..., timeout=...) for item in collection]
 
         The comprehension must have exactly one generator with no conditions,
-        and the element must be an action call.
+        and the element must be an action call (optionally wrapped in run_action).
 
         Args:
             listcomp: The ListComp AST node
@@ -2653,7 +2865,7 @@ class IRBuilder(ast.NodeVisitor):
         loop_var = gen.target.id
 
         # Get the collection expression
-        collection_expr = _expr_to_ir(gen.iter)
+        collection_expr = self._expr_to_ir_with_model_coercion(gen.iter)
         if not collection_expr:
             line = getattr(listcomp, "lineno", None)
             col = getattr(listcomp, "col_offset", None)
@@ -2664,7 +2876,7 @@ class IRBuilder(ast.NodeVisitor):
                 col=col,
             )
 
-        # The element must be an action call
+        # The element must be a call (either action call or run_action wrapper)
         if not isinstance(listcomp.elt, ast.Call):
             line = getattr(listcomp, "lineno", None)
             col = getattr(listcomp, "col_offset", None)
@@ -2675,13 +2887,27 @@ class IRBuilder(ast.NodeVisitor):
                 col=col,
             )
 
-        action_call = self._extract_action_call_from_call(listcomp.elt)
+        # Check for self.run_action(...) wrapper pattern
+        action_call: Optional[ir.ActionCall] = None
+        if self._is_run_action_call(listcomp.elt):
+            # Extract the inner action call from run_action's first argument
+            if listcomp.elt.args:
+                inner_call = listcomp.elt.args[0]
+                if isinstance(inner_call, ast.Call):
+                    action_call = self._extract_action_call_from_call(inner_call)
+                    if action_call:
+                        # Extract policies (retry, timeout) from run_action kwargs
+                        self._extract_policies_from_run_action(listcomp.elt, action_call)
+        else:
+            # Direct action call
+            action_call = self._extract_action_call_from_call(listcomp.elt)
+
         if not action_call:
             line = getattr(listcomp, "lineno", None)
             col = getattr(listcomp, "col_offset", None)
             raise UnsupportedPatternError(
                 "Spread pattern element must be an @action call",
-                "Ensure the function is decorated with @action",
+                "Ensure the function is decorated with @action, or use self.run_action(action(...), ...)",
                 line=line,
                 col=col,
             )
@@ -2725,20 +2951,26 @@ class IRBuilder(ast.NodeVisitor):
             return None
 
         fn_call = ir.FunctionCall(name=func_name)
+        global_function = _global_function_for_call(func_name, node)
+        if global_function is not None:
+            fn_call.global_function = global_function
 
         # Add positional args
         for arg in node.args:
-            expr = _expr_to_ir(arg)
+            expr = self._expr_to_ir_with_model_coercion(arg)
             if expr:
                 fn_call.args.append(expr)
 
         # Add keyword args
         for kw in node.keywords:
             if kw.arg:
-                expr = _expr_to_ir(kw.value)
+                expr = self._expr_to_ir_with_model_coercion(kw.value)
                 if expr:
                     fn_call.kwargs.append(ir.Kwarg(name=kw.arg, value=expr))
 
+        # Fill in missing kwargs with default values from function signature
+        self._fill_default_kwargs_for_expr(fn_call)
+
         return fn_call
 
     def _get_func_name(self, node: ast.expr) -> Optional[str]:
@@ -2754,27 +2986,147 @@ class IRBuilder(ast.NodeVisitor):
                 current = current.value
             if isinstance(current, ast.Name):
                 parts.append(current.id)
-            return ".".join(reversed(parts))
+            name = ".".join(reversed(parts))
+            if name.startswith("self."):
+                return name[5:]
+            return name
         return None
 
-    def _expr_to_ir_with_model_coercion(self, node: ast.expr) -> Optional[ir.Expr]:
-        """Convert an AST expression to IR, converting model constructors to dicts.
+    def _convert_model_constructor_if_needed(self, node: ast.Call) -> Optional[ir.Expr]:
+        model_name = self._is_model_constructor(node)
+        if model_name:
+            return self._convert_model_constructor_to_dict(node, model_name)
+        return None
 
-        This is used for action arguments where Pydantic models or dataclass
-        constructors should be converted to dict expressions that Rust can evaluate.
+    def _resolve_enum_attribute(self, node: ast.Attribute) -> Optional[ir.Expr]:
+        value = _resolve_enum_attribute_value(node, self._module_globals)
+        if value is None:
+            return None
+        literal = _constant_to_literal(value)
+        if literal is None:
+            line = getattr(node, "lineno", None)
+            col = getattr(node, "col_offset", None)
+            raise UnsupportedPatternError(
+                "Enum value must be a primitive literal",
+                RECOMMENDATIONS["unsupported_literal"],
+                line=line,
+                col=col,
+            )
+        expr = ir.Expr(span=_make_span(node))
+        expr.literal.CopyFrom(literal)
+        return expr
+
+    def _is_exception_class(self, class_name: str) -> bool:
+        """Check if a class name refers to an exception class.
 
-        If the expression is a model constructor (e.g., MyModel(field=value)),
-        it is converted to a dict expression. Otherwise, falls back to the
-        standard _expr_to_ir conversion.
+        This checks both built-in exceptions and imported exception classes.
         """
-        # Check if this is a model constructor call
-        if isinstance(node, ast.Call):
-            model_name = self._is_model_constructor(node)
-            if model_name:
-                return self._convert_model_constructor_to_dict(node, model_name)
+        # Check built-in exceptions first
+        builtin_exc = (
+            getattr(__builtins__, class_name, None)
+            if isinstance(__builtins__, dict)
+            else getattr(__builtins__, class_name, None)
+        )
+        if builtin_exc is None:
+            # Try getting from builtins module directly
+            import builtins
+
+            builtin_exc = getattr(builtins, class_name, None)
+        if (
+            builtin_exc is not None
+            and isinstance(builtin_exc, type)
+            and issubclass(builtin_exc, BaseException)
+        ):
+            return True
+
+        # Check module globals for imported exception classes
+        cls = self._module_globals.get(class_name)
+        if cls is not None and isinstance(cls, type) and issubclass(cls, BaseException):
+            return True
+
+        return False
+
+    def _expr_to_ir_with_model_coercion(self, node: ast.expr) -> Optional[ir.Expr]:
+        """Convert an AST expression to IR, converting model constructors to dicts."""
+        result = _expr_to_ir(
+            node,
+            model_converter=self._convert_model_constructor_if_needed,
+            enum_resolver=self._resolve_enum_attribute,
+            exception_class_resolver=self._is_exception_class,
+        )
+        # Post-process to fill in default kwargs for function calls (recursively)
+        if result is not None:
+            self._fill_default_kwargs_recursive(result)
+        return result
+
+    def _fill_default_kwargs_recursive(self, expr: ir.Expr) -> None:
+        """Recursively fill in default kwargs for all function calls in an expression."""
+        if expr.HasField("function_call"):
+            self._fill_default_kwargs_for_expr(expr.function_call)
+            # Recurse into function call args and kwargs
+            for arg in expr.function_call.args:
+                self._fill_default_kwargs_recursive(arg)
+            for kwarg in expr.function_call.kwargs:
+                if kwarg.value:
+                    self._fill_default_kwargs_recursive(kwarg.value)
+        elif expr.HasField("binary_op"):
+            if expr.binary_op.left:
+                self._fill_default_kwargs_recursive(expr.binary_op.left)
+            if expr.binary_op.right:
+                self._fill_default_kwargs_recursive(expr.binary_op.right)
+        elif expr.HasField("unary_op"):
+            if expr.unary_op.operand:
+                self._fill_default_kwargs_recursive(expr.unary_op.operand)
+        elif expr.HasField("list"):
+            for elem in expr.list.elements:
+                self._fill_default_kwargs_recursive(elem)
+        elif expr.HasField("dict"):
+            for entry in expr.dict.entries:
+                if entry.key:
+                    self._fill_default_kwargs_recursive(entry.key)
+                if entry.value:
+                    self._fill_default_kwargs_recursive(entry.value)
+        elif expr.HasField("index"):
+            if expr.index.object:
+                self._fill_default_kwargs_recursive(expr.index.object)
+            if expr.index.index:
+                self._fill_default_kwargs_recursive(expr.index.index)
+        elif expr.HasField("dot"):
+            if expr.dot.object:
+                self._fill_default_kwargs_recursive(expr.dot.object)
 
-        # Fall back to standard expression conversion
-        return _expr_to_ir(node)
+    def _fill_default_kwargs_for_expr(self, fn_call: ir.FunctionCall) -> None:
+        """Fill in missing kwargs with default values from the function signature."""
+        sig_info = self._ctx.function_signatures.get(fn_call.name)
+        if sig_info is None:
+            return
+
+        # Track which parameters are already provided
+        provided_by_position: Set[str] = set()
+        provided_by_kwarg: Set[str] = set()
+
+        # Positional args map to parameters in order
+        for idx, _arg in enumerate(fn_call.args):
+            if idx < len(sig_info.parameters):
+                provided_by_position.add(sig_info.parameters[idx].name)
+
+        # Kwargs are named
+        for kwarg in fn_call.kwargs:
+            provided_by_kwarg.add(kwarg.name)
+
+        # Add defaults for missing parameters
+        for param in sig_info.parameters:
+            if param.name in provided_by_position or param.name in provided_by_kwarg:
+                continue
+            if not param.has_default:
+                continue
+
+            # Convert the default value to an IR expression
+            literal = _constant_to_literal(param.default_value)
+            if literal is not None:
+                expr = ir.Expr()
+                expr.literal.CopyFrom(literal)
+                fn_call.kwargs.append(ir.Kwarg(name=param.name, value=expr))
 
     def _extract_action_call_from_awaitable(self, node: ast.expr) -> Optional[ir.ActionCall]:
         """Extract action call from an awaitable expression."""
@@ -2869,10 +3221,200 @@ def _make_span(node: ast.AST) -> ir.Span:
     )
 
 
-def _expr_to_ir(expr: ast.AST) -> Optional[ir.Expr]:
-    """Convert Python AST expression to IR Expr."""
+def _attribute_chain(node: ast.Attribute) -> Optional[List[str]]:
+    parts: List[str] = []
+    current: ast.AST = node
+    while isinstance(current, ast.Attribute):
+        parts.append(current.attr)
+        current = current.value
+    if isinstance(current, ast.Name):
+        parts.append(current.id)
+        return list(reversed(parts))
+    return None
+
+
+def _resolve_enum_attribute_value(
+    node: ast.Attribute,
+    module_globals: Mapping[str, Any],
+) -> Optional[Any]:
+    chain = _attribute_chain(node)
+    if not chain or len(chain) < 2:
+        return None
+
+    current = module_globals.get(chain[0])
+    if current is None:
+        return None
+
+    for part in chain[1:-1]:
+        try:
+            current_dict = current.__dict__
+        except AttributeError:
+            return None
+        current = current_dict.get(part)
+        if current is None:
+            return None
+
+    member_name = chain[-1]
+    if isinstance(current, EnumMeta):
+        member = current.__members__.get(member_name)
+        if member is None:
+            return None
+        return member.value
+
+    return None
+
+
+def _try_convert_isinstance_to_isexception(
+    expr: ast.Call,
+    exception_class_resolver: Callable[[str], bool],
+    model_converter: Optional[Callable[[ast.Call], Optional[ir.Expr]]] = None,
+    enum_resolver: Optional[Callable[[ast.Attribute], Optional[ir.Expr]]] = None,
+) -> Optional[ir.Expr]:
+    """Try to convert isinstance(x, ExceptionClass) to isexception(x, "ExceptionClass").
+
+    Returns None if this is not an isinstance call or if the class is not an exception.
+    Raises UnsupportedPatternError if isinstance is used with a non-exception class.
+    """
+    # Check if this is an isinstance call
+    func_name = _get_func_name(expr.func)
+    if func_name != "isinstance":
+        return None
+
+    # isinstance requires exactly 2 positional arguments
+    if len(expr.args) != 2 or expr.keywords:
+        line = expr.lineno if hasattr(expr, "lineno") else None
+        col = expr.col_offset if hasattr(expr, "col_offset") else None
+        raise UnsupportedPatternError(
+            "isinstance() requires exactly 2 positional arguments",
+            RECOMMENDATIONS["sync_function_call"],
+            line=line,
+            col=col,
+        )
+
+    # Extract exception class names from the second argument
+    second_arg = expr.args[1]
+    exception_names: List[str] = []
+
+    if isinstance(second_arg, ast.Name):
+        # Single class: isinstance(x, ValueError)
+        class_name = second_arg.id
+        if not exception_class_resolver(class_name):
+            line = expr.lineno if hasattr(expr, "lineno") else None
+            col = expr.col_offset if hasattr(expr, "col_offset") else None
+            raise UnsupportedPatternError(
+                f"isinstance() with non-exception class '{class_name}' is not supported in workflows",
+                "isinstance() can only be used to check exception types in workflow code. "
+                "Move other type checks to an @action.",
+                line=line,
+                col=col,
+            )
+        exception_names.append(class_name)
+    elif isinstance(second_arg, ast.Tuple):
+        # Tuple of classes: isinstance(x, (ValueError, TypeError))
+        for elt in second_arg.elts:
+            if not isinstance(elt, ast.Name):
+                line = expr.lineno if hasattr(expr, "lineno") else None
+                col = expr.col_offset if hasattr(expr, "col_offset") else None
+                raise UnsupportedPatternError(
+                    "isinstance() class argument must be a simple name or tuple of names",
+                    "Use simple class names like ValueError or (ValueError, TypeError).",
+                    line=line,
+                    col=col,
+                )
+            class_name = elt.id
+            if not exception_class_resolver(class_name):
+                line = expr.lineno if hasattr(expr, "lineno") else None
+                col = expr.col_offset if hasattr(expr, "col_offset") else None
+                raise UnsupportedPatternError(
+                    f"isinstance() with non-exception class '{class_name}' is not supported in workflows",
+                    "isinstance() can only be used to check exception types in workflow code. "
+                    "Move other type checks to an @action.",
+                    line=line,
+                    col=col,
+                )
+            exception_names.append(class_name)
+    else:
+        line = expr.lineno if hasattr(expr, "lineno") else None
+        col = expr.col_offset if hasattr(expr, "col_offset") else None
+        raise UnsupportedPatternError(
+            "isinstance() class argument must be a simple name or tuple of names",
+            "Use simple class names like ValueError or (ValueError, TypeError).",
+            line=line,
+            col=col,
+        )
+
+    # Convert the first argument (the value being checked) to IR
+    value_expr = _expr_to_ir(
+        expr.args[0],
+        model_converter=model_converter,
+        enum_resolver=enum_resolver,
+        exception_class_resolver=exception_class_resolver,
+    )
+    if not value_expr:
+        return None
+
+    # Build the isexception call
+    # If single exception: isexception(x, "ValueError")
+    # If multiple: isexception(x, ["ValueError", "TypeError"])
     result = ir.Expr(span=_make_span(expr))
 
+    if len(exception_names) == 1:
+        # Single exception name as string
+        type_arg = ir.Expr(span=_make_span(second_arg))
+        type_arg.literal.CopyFrom(ir.Literal(string_value=exception_names[0]))
+        args = [value_expr, type_arg]
+    else:
+        # Multiple exception names as list of strings
+        type_elements = []
+        for name in exception_names:
+            elem = ir.Expr()
+            elem.literal.CopyFrom(ir.Literal(string_value=name))
+            type_elements.append(elem)
+        type_arg = ir.Expr(span=_make_span(second_arg))
+        type_arg.list.CopyFrom(ir.ListExpr(elements=type_elements))
+        args = [value_expr, type_arg]
+
+    func_call = ir.FunctionCall(
+        name="isexception",
+        args=args,
+        kwargs=[],
+    )
+    func_call.global_function = ir.GlobalFunction.GLOBAL_FUNCTION_ISEXCEPTION
+    result.function_call.CopyFrom(func_call)
+    return result
+
+
+def _expr_to_ir(
+    expr: ast.AST,
+    model_converter: Optional[Callable[[ast.Call], Optional[ir.Expr]]] = None,
+    enum_resolver: Optional[Callable[[ast.Attribute], Optional[ir.Expr]]] = None,
+    exception_class_resolver: Optional[Callable[[str], bool]] = None,
+) -> Optional[ir.Expr]:
+    """Convert Python AST expression to IR Expr.
+
+    Args:
+        expr: The AST expression to convert.
+        model_converter: Optional callback to convert model constructors.
+        enum_resolver: Optional callback to resolve enum attributes.
+        exception_class_resolver: Optional callback that takes a class name and
+            returns True if it's an exception class. Used to transform
+            isinstance(x, ExceptionClass) to isexception(x, "ExceptionClass").
+    """
+    result = ir.Expr(span=_make_span(expr))
+
+    if isinstance(expr, ast.Call) and model_converter:
+        converted = model_converter(expr)
+        if converted:
+            return converted
+
+    # Handle isinstance(x, ExceptionClass) -> isexception(x, "ExceptionClass")
+    if isinstance(expr, ast.Call) and exception_class_resolver:
+        isinstance_result = _try_convert_isinstance_to_isexception(
+            expr, exception_class_resolver, model_converter, enum_resolver
+        )
+        if isinstance_result is not None:
+            return isinstance_result
+
     if isinstance(expr, ast.Name):
         result.variable.CopyFrom(ir.Variable(name=expr.id))
         return result
@@ -2884,34 +3426,66 @@ def _expr_to_ir(expr: ast.AST) -> Optional[ir.Expr]:
             return result
 
     if isinstance(expr, ast.BinOp):
-        left = _expr_to_ir(expr.left)
-        right = _expr_to_ir(expr.right)
+        left = _expr_to_ir(
+            expr.left,
+            model_converter=model_converter,
+            enum_resolver=enum_resolver,
+            exception_class_resolver=exception_class_resolver,
+        )
+        right = _expr_to_ir(
+            expr.right,
+            model_converter=model_converter,
+            enum_resolver=enum_resolver,
+            exception_class_resolver=exception_class_resolver,
+        )
         op = _bin_op_to_ir(expr.op)
         if left and right and op:
             result.binary_op.CopyFrom(ir.BinaryOp(left=left, op=op, right=right))
             return result
 
     if isinstance(expr, ast.UnaryOp):
-        operand = _expr_to_ir(expr.operand)
+        operand = _expr_to_ir(
+            expr.operand,
+            model_converter=model_converter,
+            enum_resolver=enum_resolver,
+            exception_class_resolver=exception_class_resolver,
+        )
         op = _unary_op_to_ir(expr.op)
         if operand and op:
             result.unary_op.CopyFrom(ir.UnaryOp(op=op, operand=operand))
             return result
 
     if isinstance(expr, ast.Compare):
-        left = _expr_to_ir(expr.left)
+        left = _expr_to_ir(
+            expr.left,
+            model_converter=model_converter,
+            enum_resolver=enum_resolver,
+            exception_class_resolver=exception_class_resolver,
+        )
         if not left:
             return None
         # For simplicity, handle single comparison
         if expr.ops and expr.comparators:
             op = _cmp_op_to_ir(expr.ops[0])
-            right = _expr_to_ir(expr.comparators[0])
+            right = _expr_to_ir(
+                expr.comparators[0],
+                model_converter=model_converter,
+                enum_resolver=enum_resolver,
+            )
             if op and right:
                 result.binary_op.CopyFrom(ir.BinaryOp(left=left, op=op, right=right))
                 return result
 
     if isinstance(expr, ast.BoolOp):
-        values = [_expr_to_ir(v) for v in expr.values]
+        values = [
+            _expr_to_ir(
+                v,
+                model_converter=model_converter,
+                enum_resolver=enum_resolver,
+                exception_class_resolver=exception_class_resolver,
+            )
+            for v in expr.values
+        ]
         if all(v for v in values):
             op = _bool_op_to_ir(expr.op)
             if op and len(values) >= 2:
@@ -2925,7 +3499,15 @@ def _expr_to_ir(expr: ast.AST) -> Optional[ir.Expr]:
                 return result_expr
 
     if isinstance(expr, ast.List):
-        elements = [_expr_to_ir(e) for e in expr.elts]
+        elements = [
+            _expr_to_ir(
+                e,
+                model_converter=model_converter,
+                enum_resolver=enum_resolver,
+                exception_class_resolver=exception_class_resolver,
+            )
+            for e in expr.elts
+        ]
         if all(e for e in elements):
             list_expr = ir.ListExpr(elements=[e for e in elements if e])
             result.list.CopyFrom(list_expr)
@@ -2935,35 +3517,128 @@ def _expr_to_ir(expr: ast.AST) -> Optional[ir.Expr]:
         entries: List[ir.DictEntry] = []
         for k, v in zip(expr.keys, expr.values, strict=False):
             if k:
-                key_expr = _expr_to_ir(k)
-                value_expr = _expr_to_ir(v)
+                key_expr = _expr_to_ir(
+                    k,
+                    model_converter=model_converter,
+                    enum_resolver=enum_resolver,
+                )
+                value_expr = _expr_to_ir(
+                    v,
+                    model_converter=model_converter,
+                    enum_resolver=enum_resolver,
+                )
                 if key_expr and value_expr:
                     entries.append(ir.DictEntry(key=key_expr, value=value_expr))
         result.dict.CopyFrom(ir.DictExpr(entries=entries))
         return result
 
     if isinstance(expr, ast.Subscript):
-        obj = _expr_to_ir(expr.value)
-        index = _expr_to_ir(expr.slice) if isinstance(expr.slice, ast.AST) else None
+        obj = _expr_to_ir(
+            expr.value,
+            model_converter=model_converter,
+            enum_resolver=enum_resolver,
+            exception_class_resolver=exception_class_resolver,
+        )
+        index = (
+            _expr_to_ir(
+                expr.slice,
+                model_converter=model_converter,
+                enum_resolver=enum_resolver,
+            )
+            if isinstance(expr.slice, ast.AST)
+            else None
+        )
         if obj and index:
             result.index.CopyFrom(ir.IndexAccess(object=obj, index=index))
             return result
 
     if isinstance(expr, ast.Attribute):
-        obj = _expr_to_ir(expr.value)
+        if enum_resolver:
+            resolved = enum_resolver(expr)
+            if resolved:
+                return resolved
+        obj = _expr_to_ir(
+            expr.value,
+            model_converter=model_converter,
+            enum_resolver=enum_resolver,
+            exception_class_resolver=exception_class_resolver,
+        )
         if obj:
             result.dot.CopyFrom(ir.DotAccess(object=obj, attribute=expr.attr))
             return result
 
+    if isinstance(expr, ast.Await) and isinstance(expr.value, ast.Call):
+        func_name = _get_func_name(expr.value.func)
+        if func_name:
+            args = [
+                _expr_to_ir(
+                    a,
+                    model_converter=model_converter,
+                    enum_resolver=enum_resolver,
+                )
+                for a in expr.value.args
+            ]
+            kwargs: List[ir.Kwarg] = []
+            for kw in expr.value.keywords:
+                if kw.arg:
+                    kw_expr = _expr_to_ir(
+                        kw.value,
+                        model_converter=model_converter,
+                        enum_resolver=enum_resolver,
+                    )
+                    if kw_expr:
+                        kwargs.append(ir.Kwarg(name=kw.arg, value=kw_expr))
+            func_call = ir.FunctionCall(
+                name=func_name,
+                args=[a for a in args if a],
+                kwargs=kwargs,
+            )
+            global_function = _global_function_for_call(func_name, expr.value)
+            if global_function is not None:
+                func_call.global_function = global_function
+            result.function_call.CopyFrom(func_call)
+            return result
+
     if isinstance(expr, ast.Call):
         # Function call
+        if not _is_self_method_call(expr):
+            func_name = _get_func_name(expr.func) or "unknown"
+            if isinstance(expr.func, ast.Attribute):
+                line = expr.lineno if hasattr(expr, "lineno") else None
+                col = expr.col_offset if hasattr(expr, "col_offset") else None
+                raise UnsupportedPatternError(
+                    f"Calling synchronous function '{func_name}()' directly is not supported",
+                    RECOMMENDATIONS["sync_function_call"],
+                    line=line,
+                    col=col,
+                )
+            if func_name not in ALLOWED_SYNC_FUNCTIONS:
+                line = expr.lineno if hasattr(expr, "lineno") else None
+                col = expr.col_offset if hasattr(expr, "col_offset") else None
+                raise UnsupportedPatternError(
+                    f"Calling synchronous function '{func_name}()' directly is not supported",
+                    RECOMMENDATIONS["sync_function_call"],
+                    line=line,
+                    col=col,
+                )
         func_name = _get_func_name(expr.func)
         if func_name:
-            args = [_expr_to_ir(a) for a in expr.args]
+            args = [
+                _expr_to_ir(
+                    a,
+                    model_converter=model_converter,
+                    enum_resolver=enum_resolver,
+                )
+                for a in expr.args
+            ]
             kwargs: List[ir.Kwarg] = []
             for kw in expr.keywords:
                 if kw.arg:
-                    kw_expr = _expr_to_ir(kw.value)
+                    kw_expr = _expr_to_ir(
+                        kw.value,
+                        model_converter=model_converter,
+                        enum_resolver=enum_resolver,
+                    )
                     if kw_expr:
                         kwargs.append(ir.Kwarg(name=kw.arg, value=kw_expr))
             func_call = ir.FunctionCall(
@@ -2971,12 +3646,23 @@ def _expr_to_ir(expr: ast.AST) -> Optional[ir.Expr]:
                 args=[a for a in args if a],
                 kwargs=kwargs,
             )
+            global_function = _global_function_for_call(func_name, expr)
+            if global_function is not None:
+                func_call.global_function = global_function
             result.function_call.CopyFrom(func_call)
             return result
 
     if isinstance(expr, ast.Tuple):
         # Handle tuple as list for now
-        elements = [_expr_to_ir(e) for e in expr.elts]
+        elements = [
+            _expr_to_ir(
+                e,
+                model_converter=model_converter,
+                enum_resolver=enum_resolver,
+                exception_class_resolver=exception_class_resolver,
+            )
+            for e in expr.elts
+        ]
         if all(e for e in elements):
             list_expr = ir.ListExpr(elements=[e for e in elements if e])
             result.list.CopyFrom(list_expr)
@@ -2993,6 +3679,15 @@ def _check_unsupported_expression(expr: ast.AST) -> None:
     line = getattr(expr, "lineno", None)
     col = getattr(expr, "col_offset", None)
 
+    if isinstance(expr, ast.Constant):
+        if _constant_to_literal(expr.value) is None:
+            raise UnsupportedPatternError(
+                f"Unsupported literal type '{type(expr.value).__name__}'",
+                RECOMMENDATIONS["unsupported_literal"],
+                line=line,
+                col=col,
+            )
+
     if isinstance(expr, ast.JoinedStr):
         raise UnsupportedPatternError(
             "F-strings are not supported",
@@ -3049,6 +3744,13 @@ def _check_unsupported_expression(expr: ast.AST) -> None:
             line=line,
             col=col,
         )
+    elif isinstance(expr, ast.expr):
+        raise UnsupportedPatternError(
+            f"Unsupported expression type '{type(expr).__name__}'",
+            RECOMMENDATIONS["unsupported_expression"],
+            line=line,
+            col=col,
+        )
 
 
 def _format_subscript_target(target: ast.Subscript) -> Optional[str]:
@@ -3142,5 +3844,27 @@ def _get_func_name(func: ast.expr) -> Optional[str]:
             current = current.value
         if isinstance(current, ast.Name):
             parts.append(current.id)
-        return ".".join(reversed(parts))
+        name = ".".join(reversed(parts))
+        if name.startswith("self."):
+            return name[5:]
+        return name
     return None
+
+
+def _is_self_method_call(node: ast.Call) -> bool:
+    """Return True if the call is a direct self.method(...) invocation."""
+    func = node.func
+    return (
+        isinstance(func, ast.Attribute)
+        and isinstance(func.value, ast.Name)
+        and func.value.id == "self"
+    )
+
+
+def _global_function_for_call(
+    func_name: str, node: ast.Call
+) -> Optional[ir.GlobalFunction.ValueType]:
+    """Return the GlobalFunction enum value for supported globals."""
+    if _is_self_method_call(node):
+        return None
+    return GLOBAL_FUNCTIONS.get(func_name)