@workflow/builders 4.0.1-beta.6 → 4.0.1-beta.60

package/dist/workflows-extractor.js

@@ -0,0 +1,1476 @@
+import { readFile } from 'node:fs/promises';
+import { parseSync } from '@swc/core';
+// ============================================================================
+// Constants
+// ============================================================================
+/**
+ * Workflow primitives that should be shown as nodes in the graph.
+ * These are built-in workflow functions that represent meaningful
+ * pauses or wait points in the workflow execution.
+ */
+const WORKFLOW_PRIMITIVES = new Set(['sleep', 'createHook', 'createWebhook']);
+/**
+ * Extract the original function name from a stepId.
+ * stepId format: "step//path/to/file.ts//functionName"
+ * The bundler may rename functions to avoid collisions (e.g. add -> add2),
+ * but the stepId contains the original TypeScript function name.
+ */
+function getOriginalStepName(stepId, fallbackName) {
+    const parts = stepId.split('//');
+    return parts.length > 2 ? parts[2] : fallbackName;
+}
+/**
+ * Extract a readable condition text from an Expression AST node.
+ * Recursively builds a string representation of the condition.
+ */
+function getConditionText(expr) {
+    switch (expr.type) {
+        case 'Identifier':
+            return expr.value;
+        case 'BooleanLiteral':
+            return String(expr.value);
+        case 'NumericLiteral':
+            return String(expr.value);
+        case 'StringLiteral':
+            return `"${expr.value}"`;
+        case 'BinaryExpression': {
+            const bin = expr;
+            const left = getConditionText(bin.left);
+            const right = getConditionText(bin.right);
+            return `${left} ${bin.operator} ${right}`;
+        }
+        case 'UnaryExpression': {
+            const unary = expr;
+            const arg = getConditionText(unary.argument);
+            return `${unary.operator}${arg}`;
+        }
+        case 'MemberExpression': {
+            const member = expr;
+            const obj = getConditionText(member.object);
+            if (member.property.type === 'Identifier') {
+                return `${obj}.${member.property.value}`;
+            }
+            if (member.property.type === 'Computed') {
+                const computed = member.property.expression;
+                return `${obj}[${getConditionText(computed)}]`;
+            }
+            return obj;
+        }
+        case 'CallExpression': {
+            const call = expr;
+            const callee = call.callee;
+            // Handle callee which could be Expression, Super, or Import
+            if (callee.type === 'Super' || callee.type === 'Import') {
+                return `${callee.type.toLowerCase()}()`;
+            }
+            return `${getConditionText(callee)}()`;
+        }
+        case 'ParenthesisExpression': {
+            const paren = expr;
+            return `(${getConditionText(paren.expression)})`;
+        }
+        default:
+            return 'condition';
+    }
+}
+// =============================================================================
+// Extraction Functions
+// =============================================================================
+/**
+ * Extracts workflow graphs from a bundled workflow file.
+ * Returns workflow entries organized by file path, ready for merging into Manifest.
+ */
+export async function extractWorkflowGraphs(bundlePath) {
+    const bundleCode = await readFile(bundlePath, 'utf-8');
+    try {
+        let actualWorkflowCode = bundleCode;
+        const bundleAst = parseSync(bundleCode, {
+            syntax: 'ecmascript',
+            target: 'es2022',
+        });
+        const workflowCodeValue = extractWorkflowCodeFromBundle(bundleAst);
+        if (workflowCodeValue) {
+            actualWorkflowCode = workflowCodeValue;
+        }
+        const ast = parseSync(actualWorkflowCode, {
+            syntax: 'ecmascript',
+            target: 'es2022',
+        });
+        const stepDeclarations = extractStepDeclarations(actualWorkflowCode);
+        const functionMap = buildFunctionMap(ast, stepDeclarations);
+        const variableMap = buildVariableMap(ast);
+        return extractWorkflows(ast, stepDeclarations, functionMap, variableMap);
+    }
+    catch (error) {
+        console.error('Failed to extract workflow graphs from bundle:', error);
+        return {};
+    }
+}
+/**
+ * Extract the workflowCode string value from a parsed bundle AST
+ */
+function extractWorkflowCodeFromBundle(ast) {
+    for (const item of ast.body) {
+        if (item.type === 'VariableDeclaration') {
+            for (const decl of item.declarations) {
+                if (decl.id.type === 'Identifier' &&
+                    decl.id.value === 'workflowCode' &&
+                    decl.init) {
+                    if (decl.init.type === 'TemplateLiteral') {
+                        return decl.init.quasis.map((q) => q.cooked || q.raw).join('');
+                    }
+                    if (decl.init.type === 'StringLiteral') {
+                        return decl.init.value;
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract step declarations using regex for speed
+ */
+function extractStepDeclarations(bundleCode) {
+    const stepDeclarations = new Map();
+    const stepPattern = /var (\w+) = globalThis\[Symbol\.for\("WORKFLOW_USE_STEP"\)\]\("([^"]+)"\)/g;
+    const lines = bundleCode.split('\n');
+    for (const line of lines) {
+        stepPattern.lastIndex = 0;
+        const match = stepPattern.exec(line);
+        if (match) {
+            const [, varName, stepId] = match;
+            stepDeclarations.set(varName, { stepId });
+        }
+    }
+    return stepDeclarations;
+}
+/**
+ * Extract inline step declarations from within a function body.
+ * These are steps defined as variable declarations inside a workflow function.
+ * Pattern: var/const varName = globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId")
+ */
+function extractInlineStepDeclarations(stmts) {
+    const inlineSteps = new Map();
+    for (const stmt of stmts) {
+        if (stmt.type === 'VariableDeclaration') {
+            const varDecl = stmt;
+            for (const decl of varDecl.declarations) {
+                if (decl.id.type === 'Identifier' &&
+                    decl.init?.type === 'CallExpression') {
+                    const callExpr = decl.init;
+                    // Check for globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId") pattern
+                    if (callExpr.callee.type === 'MemberExpression') {
+                        const member = callExpr.callee;
+                        // Check if object is globalThis
+                        if (member.object.type === 'Identifier' &&
+                            member.object.value === 'globalThis' &&
+                            member.property.type === 'Computed') {
+                            // For computed member access globalThis[Symbol.for(...)],
+                            // the property is a Computed type containing the expression
+                            const computedExpr = member.property.expression;
+                            if (computedExpr?.type === 'CallExpression') {
+                                const symbolCall = computedExpr;
+                                // Check if it's Symbol.for("WORKFLOW_USE_STEP")
+                                if (symbolCall.callee.type === 'MemberExpression') {
+                                    const symbolMember = symbolCall.callee;
+                                    if (symbolMember.object.type === 'Identifier' &&
+                                        symbolMember.object.value === 'Symbol' &&
+                                        symbolMember.property.type === 'Identifier' &&
+                                        symbolMember.property.value === 'for' &&
+                                        symbolCall.arguments.length > 0 &&
+                                        symbolCall.arguments[0].expression.type ===
+                                            'StringLiteral' &&
+                                        symbolCall.arguments[0].expression.value ===
+                                            'WORKFLOW_USE_STEP') {
+                                        // Extract the stepId from the outer call arguments
+                                        if (callExpr.arguments.length > 0 &&
+                                            callExpr.arguments[0].expression.type === 'StringLiteral') {
+                                            const stepId = callExpr.arguments[0].expression
+                                                .value;
+                                            const varName = decl.id.value;
+                                            inlineSteps.set(varName, { stepId });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return inlineSteps;
+}
+/**
+ * Build a map of all functions in the bundle for transitive step resolution
+ */
+function buildFunctionMap(ast, stepDeclarations) {
+    const functionMap = new Map();
+    for (const item of ast.body) {
+        if (item.type === 'FunctionDeclaration') {
+            const func = item;
+            if (func.identifier) {
+                const name = func.identifier.value;
+                const isStep = stepDeclarations.has(name);
+                functionMap.set(name, {
+                    name,
+                    body: func.body,
+                    isStep,
+                    stepId: isStep ? stepDeclarations.get(name)?.stepId : undefined,
+                });
+            }
+        }
+        if (item.type === 'VariableDeclaration') {
+            const varDecl = item;
+            for (const decl of varDecl.declarations) {
+                if (decl.id.type === 'Identifier' && decl.init) {
+                    const name = decl.id.value;
+                    const isStep = stepDeclarations.has(name);
+                    if (decl.init.type === 'FunctionExpression') {
+                        const funcExpr = decl.init;
+                        functionMap.set(name, {
+                            name,
+                            body: funcExpr.body,
+                            isStep,
+                            stepId: isStep ? stepDeclarations.get(name)?.stepId : undefined,
+                        });
+                    }
+                    else if (decl.init.type === 'ArrowFunctionExpression') {
+                        const arrowFunc = decl.init;
+                        functionMap.set(name, {
+                            name,
+                            body: arrowFunc.body,
+                            isStep,
+                            stepId: isStep ? stepDeclarations.get(name)?.stepId : undefined,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return functionMap;
+}
+/**
+ * Build a map of variable definitions (objects) for tool resolution
+ * This allows us to resolve tools objects to the actual tools object
+ */
+function buildVariableMap(ast) {
+    const variableMap = new Map();
+    for (const item of ast.body) {
+        if (item.type === 'VariableDeclaration') {
+            const varDecl = item;
+            for (const decl of varDecl.declarations) {
+                if (decl.type === 'VariableDeclarator' &&
+                    decl.id.type === 'Identifier' &&
+                    decl.init?.type === 'ObjectExpression') {
+                    variableMap.set(decl.id.value, decl.init);
+                }
+            }
+        }
+    }
+    return variableMap;
+}
+/**
+ * Extract workflows from AST
+ */
+function extractWorkflows(ast, stepDeclarations, functionMap, variableMap) {
+    const result = {};
+    for (const item of ast.body) {
+        if (item.type === 'FunctionDeclaration') {
+            const func = item;
+            if (!func.identifier)
+                continue;
+            const workflowName = func.identifier.value;
+            const workflowId = findWorkflowId(ast, workflowName);
+            if (!workflowId)
+                continue;
+            // Extract file path and actual workflow name from workflowId: "workflow//path/to/file.ts//functionName"
+            // The bundler may rename functions to avoid collisions (e.g. addTenWorkflow -> addTenWorkflow2),
+            // but the workflowId contains the original TypeScript function name.
+            const parts = workflowId.split('//');
+            const filePath = parts.length > 1 ? parts[1] : 'unknown';
+            const actualWorkflowName = parts.length > 2 ? parts[2] : workflowName;
+            const graph = analyzeWorkflowFunction(func, workflowName, stepDeclarations, functionMap, variableMap);
+            if (!result[filePath]) {
+                result[filePath] = {};
+            }
+            result[filePath][actualWorkflowName] = {
+                workflowId,
+                graph,
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Find workflowId assignment for a function
+ */
+function findWorkflowId(ast, functionName) {
+    for (const item of ast.body) {
+        if (item.type === 'ExpressionStatement') {
+            const expr = item.expression;
+            if (expr.type === 'AssignmentExpression') {
+                const left = expr.left;
+                if (left.type === 'MemberExpression') {
+                    const obj = left.object;
+                    const prop = left.property;
+                    if (obj.type === 'Identifier' &&
+                        obj.value === functionName &&
+                        prop.type === 'Identifier' &&
+                        prop.value === 'workflowId') {
+                        const right = expr.right;
+                        if (right.type === 'StringLiteral') {
+                            return right.value;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Analyze a workflow function and build its graph
+ */
+function analyzeWorkflowFunction(func, workflowName, stepDeclarations, functionMap, variableMap) {
+    const nodes = [];
+    const edges = [];
+    // Add start node
+    nodes.push({
+        id: 'start',
+        type: 'workflowStart',
+        data: {
+            label: `Start: ${workflowName}`,
+            nodeKind: 'workflow_start',
+        },
+    });
+    const context = {
+        parallelCounter: 0,
+        loopCounter: 0,
+        conditionalCounter: 0,
+        nodeCounter: 0,
+        inLoop: null,
+        inConditional: null,
+        webhookVariables: new Set(),
+        promiseArrays: new Map(),
+    };
+    let prevExitIds = ['start'];
+    if (func.body?.stmts) {
+        // Extract inline step declarations from the workflow body
+        // These are steps defined as variables inside the workflow function
+        const inlineSteps = extractInlineStepDeclarations(func.body.stmts);
+        // Merge inline steps with global step declarations
+        const mergedStepDeclarations = new Map(stepDeclarations);
+        for (const [name, info] of inlineSteps) {
+            mergedStepDeclarations.set(name, info);
+        }
+        for (const stmt of func.body.stmts) {
+            const result = analyzeStatement(stmt, mergedStepDeclarations, context, functionMap, variableMap);
+            nodes.push(...result.nodes);
+            edges.push(...result.edges);
+            for (const prevId of prevExitIds) {
+                for (const entryId of result.entryNodeIds) {
+                    const edgeId = `e_${prevId}_${entryId}`;
+                    if (!edges.find((e) => e.id === edgeId)) {
+                        const targetNode = result.nodes.find((n) => n.id === entryId);
+                        // Only use 'parallel' type for parallel group connections
+                        // Sequential connections (including to/from loops) should be 'default'
+                        const edgeType = targetNode?.metadata?.parallelGroupId
+                            ? 'parallel'
+                            : 'default';
+                        edges.push({
+                            id: edgeId,
+                            source: prevId,
+                            target: entryId,
+                            type: edgeType,
+                        });
+                    }
+                }
+            }
+            if (result.exitNodeIds.length > 0) {
+                prevExitIds = result.exitNodeIds;
+            }
+        }
+    }
+    // Add end node
+    nodes.push({
+        id: 'end',
+        type: 'workflowEnd',
+        data: {
+            label: 'Return',
+            nodeKind: 'workflow_end',
+        },
+    });
+    for (const prevId of prevExitIds) {
+        edges.push({
+            id: `e_${prevId}_end`,
+            source: prevId,
+            target: 'end',
+            type: 'default',
+        });
+    }
+    return { nodes, edges };
+}
+/**
+ * Check if a statement or block contains await expressions (recursively)
+ * Used to determine if a for/while loop is truly a looping execution pattern
+ * vs just collecting promises for parallel execution
+ */
+function containsAwaitExpression(node) {
+    if (!node)
+        return false;
+    // Direct await expression
+    if (node.type === 'AwaitExpression')
+        return true;
+    // Check block statements
+    if (node.type === 'BlockStatement' && node.stmts) {
+        return node.stmts.some((stmt) => containsAwaitExpression(stmt));
+    }
+    // Check expression statements
+    if (node.type === 'ExpressionStatement' && node.expression) {
+        return containsAwaitExpression(node.expression);
+    }
+    // Check variable declarations
+    if (node.type === 'VariableDeclaration' && node.declarations) {
+        return node.declarations.some((decl) => decl.init && containsAwaitExpression(decl.init));
+    }
+    // Check if statements
+    if (node.type === 'IfStatement') {
+        return (containsAwaitExpression(node.consequent) ||
+            containsAwaitExpression(node.alternate));
+    }
+    // Check for statements
+    if (node.type === 'ForStatement' ||
+        node.type === 'WhileStatement' ||
+        node.type === 'ForOfStatement' ||
+        node.type === 'ForInStatement') {
+        return containsAwaitExpression(node.body);
+    }
+    // Check assignment expressions (e.g., result = await doWork())
+    if (node.type === 'AssignmentExpression') {
+        return containsAwaitExpression(node.right);
+    }
+    // Check call expressions (for await in arguments)
+    if (node.type === 'CallExpression') {
+        if (node.arguments) {
+            return node.arguments.some((arg) => containsAwaitExpression(arg.expression || arg));
+        }
+    }
+    return false;
+}
+/**
+ * Analyze a statement and extract step calls with proper CFG structure
+ */
+function analyzeStatement(stmt, stepDeclarations, context, functionMap, variableMap) {
+    const nodes = [];
+    const edges = [];
+    let entryNodeIds = [];
+    let exitNodeIds = [];
+    if (stmt.type === 'VariableDeclaration') {
+        const varDecl = stmt;
+        for (const decl of varDecl.declarations) {
+            if (decl.init) {
+                // Track webhook/hook variable assignments: const webhook = createWebhook()
+                if (decl.id.type === 'Identifier' &&
+                    decl.init.type === 'CallExpression' &&
+                    decl.init.callee.type === 'Identifier') {
+                    const funcName = decl.init.callee
+                        .value;
+                    if (funcName === 'createWebhook' || funcName === 'createHook') {
+                        context.webhookVariables.add(decl.id.value);
+                    }
+                }
+                // Track empty array assignments for Promise.all pattern: const promises = []
+                if (decl.id.type === 'Identifier' &&
+                    decl.init.type === 'ArrayExpression') {
+                    const elements = decl.init.elements;
+                    // Empty array: elements is undefined, null, or empty array
+                    if (!elements || elements.length === 0) {
+                        const varName = decl.id.value;
+                        context.promiseArrays.set(varName, []);
+                    }
+                }
+                const result = analyzeExpression(decl.init, stepDeclarations, context, functionMap, variableMap);
+                nodes.push(...result.nodes);
+                edges.push(...result.edges);
+                if (entryNodeIds.length === 0) {
+                    entryNodeIds = result.entryNodeIds;
+                }
+                else {
+                    for (const prevId of exitNodeIds) {
+                        for (const entryId of result.entryNodeIds) {
+                            edges.push({
+                                id: `e_${prevId}_${entryId}`,
+                                source: prevId,
+                                target: entryId,
+                                type: 'default',
+                            });
+                        }
+                    }
+                }
+                exitNodeIds = result.exitNodeIds;
+            }
+        }
+    }
+    if (stmt.type === 'ExpressionStatement') {
+        const result = analyzeExpression(stmt.expression, stepDeclarations, context, functionMap, variableMap);
+        nodes.push(...result.nodes);
+        edges.push(...result.edges);
+        entryNodeIds = result.entryNodeIds;
+        exitNodeIds = result.exitNodeIds;
+    }
+    if (stmt.type === 'IfStatement') {
+        const savedConditional = context.inConditional;
+        const conditionalId = `cond_${context.conditionalCounter++}`;
+        context.inConditional = conditionalId;
+        // Analyze the "then" branch first to check if it has any workflow-relevant nodes
+        let thenResult;
+        if (stmt.consequent.type === 'BlockStatement') {
+            thenResult = analyzeBlock(stmt.consequent.stmts, stepDeclarations, context, functionMap, variableMap);
+        }
+        else {
+            // Handle single-statement consequent (no braces)
+            thenResult = analyzeStatement(stmt.consequent, stepDeclarations, context, functionMap, variableMap);
+        }
+        // Analyze the "else" branch if it exists
+        let elseResult = null;
+        if (stmt.alternate) {
+            if (stmt.alternate.type === 'BlockStatement') {
+                elseResult = analyzeBlock(stmt.alternate.stmts, stepDeclarations, context, functionMap, variableMap);
+            }
+            else {
+                // Handle single-statement alternate (no braces) or else-if
+                elseResult = analyzeStatement(stmt.alternate, stepDeclarations, context, functionMap, variableMap);
+            }
+        }
+        // Only create conditional node if at least one branch has workflow-relevant nodes.
+        // This avoids creating nodes for runtime assertions like `if (!ctx) { throw ... }`
+        const thenHasNodes = thenResult.nodes.length > 0;
+        const elseHasNodes = elseResult ? elseResult.nodes.length > 0 : false;
+        if (thenHasNodes || elseHasNodes) {
+            // Create the conditional decision node
+            const conditionText = getConditionText(stmt.test);
+            const condNodeId = `${conditionalId}_node`;
+            const condMetadata = {};
+            if (context.inLoop) {
+                condMetadata.loopId = context.inLoop;
+            }
+            const condNode = {
+                id: condNodeId,
+                type: 'conditional',
+                data: {
+                    label: conditionText,
+                    nodeKind: 'conditional',
+                },
+                metadata: Object.keys(condMetadata).length > 0 ? condMetadata : undefined,
+            };
+            nodes.push(condNode);
+            // The conditional node is the entry point
+            entryNodeIds.push(condNodeId);
+            for (const node of thenResult.nodes) {
+                if (!node.metadata)
+                    node.metadata = {};
+                node.metadata.conditionalId = conditionalId;
+                node.metadata.conditionalBranch = 'Then';
+            }
+            nodes.push(...thenResult.nodes);
+            edges.push(...thenResult.edges);
+            // Create edge from conditional node to "then" branch with "true" label
+            for (const thenEntryId of thenResult.entryNodeIds) {
+                edges.push({
+                    id: `e_${condNodeId}_${thenEntryId}_true`,
+                    source: condNodeId,
+                    target: thenEntryId,
+                    type: 'conditional',
+                    label: 'true',
+                });
+            }
+            exitNodeIds.push(...thenResult.exitNodeIds);
+            if (elseResult) {
+                for (const node of elseResult.nodes) {
+                    if (!node.metadata)
+                        node.metadata = {};
+                    node.metadata.conditionalId = conditionalId;
+                    node.metadata.conditionalBranch = 'Else';
+                }
+                nodes.push(...elseResult.nodes);
+                edges.push(...elseResult.edges);
+                // Create edge from conditional node to "else" branch with "false" label
+                for (const elseEntryId of elseResult.entryNodeIds) {
+                    edges.push({
+                        id: `e_${condNodeId}_${elseEntryId}_false`,
+                        source: condNodeId,
+                        target: elseEntryId,
+                        type: 'conditional',
+                        label: 'false',
+                    });
+                }
+                exitNodeIds.push(...elseResult.exitNodeIds);
+            }
+        }
+        // Note: When there's no else branch, we don't add the conditional node as an exit.
+        // The then-branch exits are the only exits. This means the graph shows the "true" path;
+        // the "false" case (when condition is false and there's no else) implicitly means
+        // execution continues with no steps from this if statement.
+        //
+        // When both branches have no workflow-relevant nodes (e.g., runtime assertions like
+        // `if (!ctx) { throw ... }`), we skip creating the conditional node entirely.
+        context.inConditional = savedConditional;
+    }
+    if (stmt.type === 'WhileStatement' || stmt.type === 'ForStatement') {
+        const body = stmt.type === 'WhileStatement' ? stmt.body : stmt.body;
+        // Only treat as a loop if the body contains await expressions
+        // Otherwise it's likely a "collect promises" pattern (for parallel execution)
+        const hasAwait = containsAwaitExpression(body);
+        const loopId = hasAwait ? `loop_${context.loopCounter++}` : undefined;
+        const savedLoop = context.inLoop;
+        if (loopId) {
+            context.inLoop = loopId;
+        }
+        if (body.type === 'BlockStatement') {
+            const loopResult = analyzeBlock(body.stmts, stepDeclarations, context, functionMap, variableMap);
+            // Only add loop metadata if this is truly a looping pattern
+            if (loopId) {
+                for (const node of loopResult.nodes) {
+                    if (!node.metadata)
+                        node.metadata = {};
+                    node.metadata.loopId = loopId;
+                }
+            }
+            nodes.push(...loopResult.nodes);
+            edges.push(...loopResult.edges);
+            entryNodeIds = loopResult.entryNodeIds;
+            exitNodeIds = loopResult.exitNodeIds;
+            // Only create loop-back edges if this is truly a looping pattern
+            if (loopId) {
+                for (const exitId of loopResult.exitNodeIds) {
+                    for (const entryId of loopResult.entryNodeIds) {
+                        edges.push({
+                            id: `e_${exitId}_back_${entryId}`,
+                            source: exitId,
+                            target: entryId,
+                            type: 'loop',
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            // Handle single-statement body (no braces)
+            const loopResult = analyzeStatement(body, stepDeclarations, context, functionMap, variableMap);
+            // Only add loop metadata if this is truly a looping pattern
+            if (loopId) {
+                for (const node of loopResult.nodes) {
+                    if (!node.metadata)
+                        node.metadata = {};
+                    node.metadata.loopId = loopId;
+                }
+            }
+            nodes.push(...loopResult.nodes);
+            edges.push(...loopResult.edges);
+            entryNodeIds = loopResult.entryNodeIds;
+            exitNodeIds = loopResult.exitNodeIds;
+            // Only create loop-back edges if this is truly a looping pattern
+            if (loopId) {
+                for (const exitId of loopResult.exitNodeIds) {
+                    for (const entryId of loopResult.entryNodeIds) {
+                        edges.push({
+                            id: `e_${exitId}_back_${entryId}`,
+                            source: exitId,
+                            target: entryId,
+                            type: 'loop',
+                        });
+                    }
+                }
+            }
+        }
+        context.inLoop = savedLoop;
+    }
+    if (stmt.type === 'ForOfStatement') {
+        const loopId = `loop_${context.loopCounter++}`;
+        const savedLoop = context.inLoop;
+        context.inLoop = loopId;
+        const isAwait = stmt.isAwait || stmt.await;
+        const body = stmt.body;
+        if (body.type === 'BlockStatement') {
+            const loopResult = analyzeBlock(body.stmts, stepDeclarations, context, functionMap, variableMap);
+            for (const node of loopResult.nodes) {
+                if (!node.metadata)
+                    node.metadata = {};
+                node.metadata.loopId = loopId;
+                node.metadata.loopIsAwait = isAwait;
+            }
+            nodes.push(...loopResult.nodes);
+            edges.push(...loopResult.edges);
+            entryNodeIds = loopResult.entryNodeIds;
+            exitNodeIds = loopResult.exitNodeIds;
+            for (const exitId of loopResult.exitNodeIds) {
+                for (const entryId of loopResult.entryNodeIds) {
+                    edges.push({
+                        id: `e_${exitId}_back_${entryId}`,
+                        source: exitId,
+                        target: entryId,
+                        type: 'loop',
+                    });
+                }
+            }
+        }
+        else {
+            // Handle single-statement body (no braces)
+            const loopResult = analyzeStatement(body, stepDeclarations, context, functionMap, variableMap);
+            for (const node of loopResult.nodes) {
+                if (!node.metadata)
+                    node.metadata = {};
+                node.metadata.loopId = loopId;
+                node.metadata.loopIsAwait = isAwait;
+            }
+            nodes.push(...loopResult.nodes);
+            edges.push(...loopResult.edges);
+            entryNodeIds = loopResult.entryNodeIds;
+            exitNodeIds = loopResult.exitNodeIds;
+            for (const exitId of loopResult.exitNodeIds) {
+                for (const entryId of loopResult.entryNodeIds) {
+                    edges.push({
+                        id: `e_${exitId}_back_${entryId}`,
+                        source: exitId,
+                        target: entryId,
+                        type: 'loop',
+                    });
+                }
+            }
+        }
+        context.inLoop = savedLoop;
+    }
+    // Handle plain BlockStatement (bare blocks like { ... })
+    if (stmt.type === 'BlockStatement') {
+        const blockResult = analyzeBlock(stmt.stmts, stepDeclarations, context, functionMap, variableMap);
+        nodes.push(...blockResult.nodes);
+        edges.push(...blockResult.edges);
+        entryNodeIds = blockResult.entryNodeIds;
+        exitNodeIds = blockResult.exitNodeIds;
+    }
+    if (stmt.type === 'ReturnStatement' && stmt.argument) {
+        const result = analyzeExpression(stmt.argument, stepDeclarations, context, functionMap, variableMap);
+        nodes.push(...result.nodes);
+        edges.push(...result.edges);
+        entryNodeIds = result.entryNodeIds;
+        exitNodeIds = result.exitNodeIds;
+    }
+    return { nodes, edges, entryNodeIds, exitNodeIds };
+}
+/**
+ * Analyze a block of statements with proper sequential chaining
+ */
+function analyzeBlock(stmts, stepDeclarations, context, functionMap, variableMap) {
+    const nodes = [];
+    const edges = [];
+    let entryNodeIds = [];
+    let currentExitIds = [];
+    for (const stmt of stmts) {
+        const result = analyzeStatement(stmt, stepDeclarations, context, functionMap, variableMap);
+        if (result.nodes.length === 0)
+            continue;
+        nodes.push(...result.nodes);
+        edges.push(...result.edges);
+        if (entryNodeIds.length === 0 && result.entryNodeIds.length > 0) {
+            entryNodeIds = result.entryNodeIds;
+        }
+        if (currentExitIds.length > 0 && result.entryNodeIds.length > 0) {
+            for (const prevId of currentExitIds) {
+                for (const entryId of result.entryNodeIds) {
+                    const targetNode = result.nodes.find((n) => n.id === entryId);
+                    const edgeType = targetNode?.metadata?.parallelGroupId
+                        ? 'parallel'
+                        : 'default';
+                    edges.push({
+                        id: `e_${prevId}_${entryId}`,
+                        source: prevId,
+                        target: entryId,
+                        type: edgeType,
+                    });
+                }
+            }
+        }
+        if (result.exitNodeIds.length > 0) {
+            currentExitIds = result.exitNodeIds;
+        }
+    }
+    return { nodes, edges, entryNodeIds, exitNodeIds: currentExitIds };
+}
+/**
+ * Analyze an expression and extract step calls
+ */
+function analyzeExpression(expr, stepDeclarations, context, functionMap, variableMap, visitedFunctions = new Set()) {
+    const nodes = [];
+    const edges = [];
+    const entryNodeIds = [];
+    const exitNodeIds = [];
+    if (expr.type === 'AwaitExpression') {
+        const awaitedExpr = expr.argument;
+        if (awaitedExpr.type === 'CallExpression') {
+            const callExpr = awaitedExpr;
+            // Check for Promise.all/race/allSettled/any
+            if (callExpr.callee.type === 'MemberExpression') {
+                const member = callExpr.callee;
+                if (member.object.type === 'Identifier' &&
+                    member.object.value === 'Promise' &&
+                    member.property.type === 'Identifier') {
+                    const method = member.property.value;
+                    if (['all', 'race', 'allSettled', 'any'].includes(method)) {
+                        const parallelId = `parallel_${context.parallelCounter++}`;
+                        if (callExpr.arguments.length > 0) {
+                            const arg = callExpr.arguments[0].expression;
+                            if (arg.type === 'ArrayExpression') {
+                                for (const element of arg.elements) {
+                                    if (element?.expression) {
+                                        const elemResult = analyzeExpression(element.expression, stepDeclarations, context, functionMap, variableMap, visitedFunctions);
+                                        for (const node of elemResult.nodes) {
+                                            if (!node.metadata)
+                                                node.metadata = {};
+                                            node.metadata.parallelGroupId = parallelId;
+                                            node.metadata.parallelMethod = method;
+                                            if (context.inLoop) {
+                                                node.metadata.loopId = context.inLoop;
+                                            }
+                                        }
+                                        nodes.push(...elemResult.nodes);
+                                        edges.push(...elemResult.edges);
+                                        entryNodeIds.push(...elemResult.entryNodeIds);
+                                        exitNodeIds.push(...elemResult.exitNodeIds);
+                                    }
+                                }
+                            }
+                            else if (arg.type === 'Identifier' &&
+                                context.promiseArrays.has(arg.value)) {
+                                // Handle Promise.all(variableName) where variable was built via push()
+                                const arrayName = arg.value;
+                                const trackedNodes = context.promiseArrays.get(arrayName);
+                                // Apply parallelGroupId to all nodes that were pushed to this array
+                                if (trackedNodes && trackedNodes.length > 0) {
+                                    for (const trackedNode of trackedNodes) {
+                                        if (!trackedNode.metadata)
+                                            trackedNode.metadata = {};
+                                        trackedNode.metadata.parallelGroupId = parallelId;
+                                        trackedNode.metadata.parallelMethod = method;
+                                        if (context.inLoop) {
+                                            trackedNode.metadata.loopId = context.inLoop;
+                                        }
+                                        // Return tracked node IDs for proper edge connections
+                                        entryNodeIds.push(trackedNode.id);
+                                        exitNodeIds.push(trackedNode.id);
+                                    }
+                                }
+                            }
+                            else {
+                                // Handle non-array arguments like array.map(stepFn)
+                                const argResult = analyzeExpression(arg, stepDeclarations, context, functionMap, variableMap, visitedFunctions);
+                                for (const node of argResult.nodes) {
+                                    if (!node.metadata)
+                                        node.metadata = {};
+                                    node.metadata.parallelGroupId = parallelId;
+                                    node.metadata.parallelMethod = method;
+                                    if (context.inLoop) {
+                                        node.metadata.loopId = context.inLoop;
+                                    }
+                                }
+                                nodes.push(...argResult.nodes);
+                                edges.push(...argResult.edges);
+                                entryNodeIds.push(...argResult.entryNodeIds);
+                                exitNodeIds.push(...argResult.exitNodeIds);
+                            }
+                        }
+                        return { nodes, edges, entryNodeIds, exitNodeIds };
+                    }
+                }
+            }
+            // Regular call - check if it's a step, workflow primitive, or helper function
+            if (callExpr.callee.type === 'Identifier') {
+                const funcName = callExpr.callee.value;
+                const stepInfo = stepDeclarations.get(funcName);
+                if (stepInfo) {
+                    const nodeId = `node_${context.nodeCounter++}`;
+                    const metadata = {};
+                    if (context.inLoop) {
+                        metadata.loopId = context.inLoop;
+                    }
+                    if (context.inConditional) {
+                        metadata.conditionalId = context.inConditional;
+                    }
+                    const node = {
+                        id: nodeId,
+                        type: 'step',
+                        data: {
+                            label: getOriginalStepName(stepInfo.stepId, funcName),
+                            nodeKind: 'step',
+                            stepId: stepInfo.stepId,
+                        },
+                        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                    };
+                    nodes.push(node);
+                    entryNodeIds.push(nodeId);
+                    exitNodeIds.push(nodeId);
+                }
+                else if (WORKFLOW_PRIMITIVES.has(funcName)) {
+                    // Handle workflow primitives like sleep
+                    const nodeId = `node_${context.nodeCounter++}`;
+                    const metadata = {};
+                    if (context.inLoop) {
+                        metadata.loopId = context.inLoop;
+                    }
+                    if (context.inConditional) {
+                        metadata.conditionalId = context.inConditional;
+                    }
+                    const node = {
+                        id: nodeId,
+                        type: 'primitive',
+                        data: {
+                            label: funcName,
+                            nodeKind: 'primitive',
+                        },
+                        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                    };
+                    nodes.push(node);
+                    entryNodeIds.push(nodeId);
+                    exitNodeIds.push(nodeId);
+                }
+                else {
+                    const transitiveResult = analyzeTransitiveCall(funcName, stepDeclarations, context, functionMap, variableMap, visitedFunctions);
+                    nodes.push(...transitiveResult.nodes);
+                    edges.push(...transitiveResult.edges);
+                    entryNodeIds.push(...transitiveResult.entryNodeIds);
+                    exitNodeIds.push(...transitiveResult.exitNodeIds);
+                }
+            }
+            // Also analyze the arguments of awaited calls for step references in objects
+            for (const arg of callExpr.arguments) {
+                if (arg.expression?.type === 'ObjectExpression') {
+                    const refResult = analyzeObjectForStepReferences(arg.expression, stepDeclarations, context, '');
+                    nodes.push(...refResult.nodes);
+                    edges.push(...refResult.edges);
+                    entryNodeIds.push(...refResult.entryNodeIds);
+                    exitNodeIds.push(...refResult.exitNodeIds);
+                }
+            }
+        }
+        // Handle await on a webhook/hook variable: await webhook
+        if (awaitedExpr.type === 'Identifier') {
+            const varName = awaitedExpr.value;
+            if (context.webhookVariables.has(varName)) {
+                const nodeId = `node_${context.nodeCounter++}`;
+                const metadata = {};
+                if (context.inLoop) {
+                    metadata.loopId = context.inLoop;
+                }
+                if (context.inConditional) {
+                    metadata.conditionalId = context.inConditional;
+                }
+                const node = {
+                    id: nodeId,
+                    type: 'primitive',
+                    data: {
+                        label: 'awaitWebhook',
+                        nodeKind: 'primitive',
+                    },
+                    metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                };
+                nodes.push(node);
+                entryNodeIds.push(nodeId);
+                exitNodeIds.push(nodeId);
+            }
+        }
+    }
+    // Non-awaited call expression
+    if (expr.type === 'CallExpression') {
+        const callExpr = expr;
+        if (callExpr.callee.type === 'Identifier') {
+            const funcName = callExpr.callee.value;
+            const stepInfo = stepDeclarations.get(funcName);
+            if (stepInfo) {
+                const nodeId = `node_${context.nodeCounter++}`;
+                const metadata = {};
+                if (context.inLoop) {
+                    metadata.loopId = context.inLoop;
+                }
+                if (context.inConditional) {
+                    metadata.conditionalId = context.inConditional;
+                }
+                const node = {
+                    id: nodeId,
+                    type: 'step',
+                    data: {
+                        label: getOriginalStepName(stepInfo.stepId, funcName),
+                        nodeKind: 'step',
+                        stepId: stepInfo.stepId,
+                    },
+                    metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                };
+                nodes.push(node);
+                entryNodeIds.push(nodeId);
+                exitNodeIds.push(nodeId);
+            }
+            else if (WORKFLOW_PRIMITIVES.has(funcName)) {
+                // Handle non-awaited workflow primitives like createHook, createWebhook
+                const nodeId = `node_${context.nodeCounter++}`;
+                const metadata = {};
+                if (context.inLoop) {
+                    metadata.loopId = context.inLoop;
+                }
+                if (context.inConditional) {
+                    metadata.conditionalId = context.inConditional;
+                }
+                const node = {
+                    id: nodeId,
+                    type: 'primitive',
+                    data: {
+                        label: funcName,
+                        nodeKind: 'primitive',
+                    },
+                    metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                };
+                nodes.push(node);
+                entryNodeIds.push(nodeId);
+                exitNodeIds.push(nodeId);
+            }
+            else {
+                const transitiveResult = analyzeTransitiveCall(funcName, stepDeclarations, context, functionMap, variableMap, visitedFunctions);
+                nodes.push(...transitiveResult.nodes);
+                edges.push(...transitiveResult.edges);
+                entryNodeIds.push(...transitiveResult.entryNodeIds);
+                exitNodeIds.push(...transitiveResult.exitNodeIds);
+            }
+        }
+    }
+    // Check for step references in object literals
+    if (expr.type === 'ObjectExpression') {
+        const refResult = analyzeObjectForStepReferences(expr, stepDeclarations, context, '');
+        nodes.push(...refResult.nodes);
+        edges.push(...refResult.edges);
+        entryNodeIds.push(...refResult.entryNodeIds);
+        exitNodeIds.push(...refResult.exitNodeIds);
+    }
+    // Check for step references and step calls in function call arguments
+    // Skip for array methods (map, forEach, etc.) which have a specialized handler below
+    if (expr.type === 'CallExpression') {
+        const callExpr = expr;
+        // Check if this is an array method call - if so, skip the generic handler
+        // and let the specialized handler at the end of this function handle it
+        const isArrayMethodCall = callExpr.callee.type === 'MemberExpression' &&
+            callExpr.callee.property.type === 'Identifier' &&
+            ['map', 'forEach', 'filter', 'find', 'some', 'every', 'flatMap'].includes(callExpr.callee.property.value);
+        // Check if this is a .push() call on a tracked promise array
+        // Pattern: promises.push(stepCall())
+        let pushArrayName = null;
+        if (callExpr.callee.type === 'MemberExpression' &&
+            callExpr.callee.object.type === 'Identifier' &&
+            callExpr.callee.property.type === 'Identifier' &&
+            callExpr.callee.property.value ===
+                'push') {
+            const objName = callExpr.callee.object.value;
+            if (context.promiseArrays.has(objName)) {
+                pushArrayName = objName;
+            }
+        }
+        for (const arg of callExpr.arguments) {
+            if (arg.expression) {
+                // For array method calls, skip step identifier detection here
+                // since we have a specialized handler for those
+                if (arg.expression.type === 'Identifier' && !isArrayMethodCall) {
+                    const argName = arg.expression.value;
+                    const stepInfo = stepDeclarations.get(argName);
+                    if (stepInfo) {
+                        const nodeId = `node_${context.nodeCounter++}`;
+                        const node = {
+                            id: nodeId,
+                            type: 'step',
+                            data: {
+                                label: `${getOriginalStepName(stepInfo.stepId, argName)} (ref)`,
+                                nodeKind: 'step',
+                                stepId: stepInfo.stepId,
+                            },
+                            metadata: {
+                                isStepReference: true,
+                                referenceContext: 'function argument',
+                            },
+                        };
+                        nodes.push(node);
+                        entryNodeIds.push(nodeId);
+                        exitNodeIds.push(nodeId);
+                    }
+                }
+                // Handle step calls passed as arguments (e.g., promises.push(stepCall()))
+                // Note: Don't add loopId here - these are non-awaited calls being collected
+                // for parallel execution (like Promise.all), not truly looping calls
+                if (arg.expression.type === 'CallExpression') {
+                    const argCallExpr = arg.expression;
+                    if (argCallExpr.callee.type === 'Identifier') {
+                        const funcName = argCallExpr.callee.value;
+                        const stepInfo = stepDeclarations.get(funcName);
+                        if (stepInfo) {
+                            const nodeId = `node_${context.nodeCounter++}`;
+                            const metadata = {};
+                            // Don't add loopId - this is a non-awaited call, likely being
+                            // collected for parallel execution (Promise.all pattern)
+                            if (context.inConditional) {
+                                metadata.conditionalId = context.inConditional;
+                            }
+                            const node = {
+                                id: nodeId,
+                                type: 'step',
+                                data: {
+                                    label: getOriginalStepName(stepInfo.stepId, funcName),
+                                    nodeKind: 'step',
+                                    stepId: stepInfo.stepId,
+                                },
+                                metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                            };
+                            // If this is being pushed to a tracked promise array, store the node
+                            // so we can apply parallelGroupId when Promise.all is reached
+                            if (pushArrayName) {
+                                const trackedNodes = context.promiseArrays.get(pushArrayName);
+                                if (trackedNodes) {
+                                    trackedNodes.push(node);
+                                }
+                            }
+                            nodes.push(node);
+                            entryNodeIds.push(nodeId);
+                            exitNodeIds.push(nodeId);
+                        }
+                    }
+                }
+                if (arg.expression.type === 'ObjectExpression') {
+                    const refResult = analyzeObjectForStepReferences(arg.expression, stepDeclarations, context, '');
+                    nodes.push(...refResult.nodes);
+                    edges.push(...refResult.edges);
+                    entryNodeIds.push(...refResult.entryNodeIds);
+                    exitNodeIds.push(...refResult.exitNodeIds);
+                }
+            }
+        }
+    }
+    // Check for step references in 'new' expressions
+    if (expr.type === 'NewExpression') {
+        const newExpr = expr;
+        // Check if this is a DurableAgent instantiation
+        const isDurableAgent = newExpr.callee?.type === 'Identifier' &&
+            newExpr.callee?.value === 'DurableAgent';
+        if (isDurableAgent && newExpr.arguments?.length > 0) {
+            // Create a node for the DurableAgent itself
+            const agentNodeId = `node_${context.nodeCounter++}`;
+            const agentNode = {
+                id: agentNodeId,
+                type: 'agent',
+                data: {
+                    label: 'DurableAgent',
+                    nodeKind: 'agent',
+                },
+                metadata: {
+                    isStepReference: true,
+                    referenceContext: 'DurableAgent',
+                },
+            };
+            nodes.push(agentNode);
+            entryNodeIds.push(agentNodeId);
+            // Look for tools in the constructor options
+            const optionsArg = newExpr.arguments[0]?.expression;
+            if (optionsArg?.type === 'ObjectExpression') {
+                const toolsResult = analyzeDurableAgentTools(optionsArg, stepDeclarations, context, agentNodeId, variableMap);
+                nodes.push(...toolsResult.nodes);
+                edges.push(...toolsResult.edges);
+                // If we found tools, they are the exit nodes
+                if (toolsResult.exitNodeIds.length > 0) {
+                    exitNodeIds.push(...toolsResult.exitNodeIds);
+                }
+                else {
+                    exitNodeIds.push(agentNodeId);
+                }
+            }
+            else {
+                exitNodeIds.push(agentNodeId);
+            }
+        }
+        else if (newExpr.arguments) {
+            for (const arg of newExpr.arguments) {
+                if (arg.expression?.type === 'ObjectExpression') {
+                    const refResult = analyzeObjectForStepReferences(arg.expression, stepDeclarations, context, '');
+                    nodes.push(...refResult.nodes);
+                    edges.push(...refResult.edges);
+                    entryNodeIds.push(...refResult.entryNodeIds);
+                    exitNodeIds.push(...refResult.exitNodeIds);
+                }
+            }
+        }
+    }
+    // Handle AssignmentExpression - analyze the right-hand side
+    if (expr.type === 'AssignmentExpression') {
+        const assignExpr = expr;
+        if (assignExpr.right) {
+            const rightResult = analyzeExpression(assignExpr.right, stepDeclarations, context, functionMap, variableMap, visitedFunctions);
+            nodes.push(...rightResult.nodes);
+            edges.push(...rightResult.edges);
+            entryNodeIds.push(...rightResult.entryNodeIds);
+            exitNodeIds.push(...rightResult.exitNodeIds);
+        }
+    }
+    // Handle MemberExpression calls like array.map(stepFn) where step is passed as callback
+    if (expr.type === 'CallExpression') {
+        const callExpr = expr;
+        if (callExpr.callee.type === 'MemberExpression') {
+            const member = callExpr.callee;
+            // Check if this is a method call like .map(), .forEach(), .filter() etc.
+            if (member.property.type === 'Identifier') {
+                const methodName = member.property.value;
+                if ([
+                    'map',
+                    'forEach',
+                    'filter',
+                    'find',
+                    'some',
+                    'every',
+                    'flatMap',
+                ].includes(methodName)) {
+                    // Check if any argument is a step function reference
+                    for (const arg of callExpr.arguments) {
+                        if (arg.expression?.type === 'Identifier') {
+                            const argName = arg.expression.value;
+                            const stepInfo = stepDeclarations.get(argName);
+                            if (stepInfo) {
+                                const nodeId = `node_${context.nodeCounter++}`;
+                                const metadata = {};
+                                if (context.inLoop) {
+                                    metadata.loopId = context.inLoop;
+                                }
+                                if (context.inConditional) {
+                                    metadata.conditionalId = context.inConditional;
+                                }
+                                const node = {
+                                    id: nodeId,
+                                    type: 'step',
+                                    data: {
+                                        label: getOriginalStepName(stepInfo.stepId, argName),
+                                        nodeKind: 'step',
+                                        stepId: stepInfo.stepId,
+                                    },
+                                    metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                                };
+                                nodes.push(node);
+                                entryNodeIds.push(nodeId);
+                                exitNodeIds.push(nodeId);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { nodes, edges, entryNodeIds, exitNodeIds };
+}
+/**
+ * Analyze DurableAgent tools property to extract tool nodes
+ */
+function analyzeDurableAgentTools(optionsObj, stepDeclarations, context, agentNodeId, variableMap) {
+    const nodes = [];
+    const edges = [];
+    const entryNodeIds = [];
+    const exitNodeIds = [];
+    if (!optionsObj.properties)
+        return { nodes, edges, entryNodeIds, exitNodeIds };
+    // Helper function to extract tools from an ObjectExpression
+    function extractToolsFromObject(toolsObj) {
+        for (const toolProp of toolsObj.properties || []) {
+            if (toolProp.type !== 'KeyValueProperty')
+                continue;
+            let toolName = '';
+            if (toolProp.key.type === 'Identifier') {
+                toolName = toolProp.key.value;
+            }
+            if (!toolName)
+                continue;
+            // Look for execute property in the tool definition
+            if (toolProp.value.type === 'ObjectExpression') {
+                for (const innerProp of toolProp.value.properties || []) {
+                    if (innerProp.type !== 'KeyValueProperty')
+                        continue;
+                    let innerKey = '';
+                    if (innerProp.key.type === 'Identifier') {
+                        innerKey = innerProp.key.value;
+                    }
+                    if (innerKey === 'execute' && innerProp.value.type === 'Identifier') {
+                        const stepName = innerProp.value.value;
+                        const stepInfo = stepDeclarations.get(stepName);
+                        const nodeId = `node_${context.nodeCounter++}`;
+                        const node = {
+                            id: nodeId,
+                            type: 'tool',
+                            data: {
+                                label: stepName,
+                                nodeKind: 'tool',
+                                stepId: stepInfo?.stepId,
+                            },
+                            metadata: {
+                                isTool: true,
+                                toolName: toolName,
+                                referenceContext: `tools.${toolName}.execute`,
+                            },
+                        };
+                        nodes.push(node);
+                        exitNodeIds.push(nodeId);
+                        // Connect agent to this tool with tool edge type
+                        edges.push({
+                            id: `e_${agentNodeId}_${nodeId}`,
+                            source: agentNodeId,
+                            target: nodeId,
+                            type: 'tool',
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Find the 'tools' property
+    for (const prop of optionsObj.properties) {
+        if (prop.type !== 'KeyValueProperty')
+            continue;
+        let keyName = '';
+        if (prop.key.type === 'Identifier') {
+            keyName = prop.key.value;
+        }
+        if (keyName !== 'tools')
+            continue;
+        // Handle inline tools object
+        if (prop.value.type === 'ObjectExpression') {
+            extractToolsFromObject(prop.value);
+        }
+        // Handle tools as a variable reference - resolve it from variableMap
+        if (prop.value.type === 'Identifier') {
+            const toolsVarName = prop.value.value;
+            // Try to resolve the variable from the variableMap (bundled code)
+            const resolvedToolsObj = variableMap.get(toolsVarName);
+            if (resolvedToolsObj && resolvedToolsObj.type === 'ObjectExpression') {
+                // Successfully resolved - extract individual tools
+                extractToolsFromObject(resolvedToolsObj);
+            }
+            else {
+                // Fallback: create a placeholder node if we can't resolve
+                const nodeId = `node_${context.nodeCounter++}`;
+                const node = {
+                    id: nodeId,
+                    type: 'tool',
+                    data: {
+                        label: `${toolsVarName}`,
+                        nodeKind: 'tool',
+                    },
+                    metadata: {
+                        isToolsCollection: true,
+                        toolsVariable: toolsVarName,
+                        referenceContext: `tools:${toolsVarName}`,
+                    },
+                };
+                nodes.push(node);
+                exitNodeIds.push(nodeId);
+                // Connect agent to tools with tool edge type
+                edges.push({
+                    id: `e_${agentNodeId}_${nodeId}`,
+                    source: agentNodeId,
+                    target: nodeId,
+                    type: 'tool',
+                });
+            }
+        }
+    }
+    return { nodes, edges, entryNodeIds, exitNodeIds };
+}
+/**
+ * Analyze an object expression for step references
+ */
+function analyzeObjectForStepReferences(obj, stepDeclarations, context, path) {
+    const nodes = [];
+    const edges = [];
+    const entryNodeIds = [];
+    const exitNodeIds = [];
+    if (!obj.properties)
+        return { nodes, edges, entryNodeIds, exitNodeIds };
+    for (const prop of obj.properties) {
+        if (prop.type !== 'KeyValueProperty')
+            continue;
+        let keyName = '';
+        if (prop.key.type === 'Identifier') {
+            keyName = prop.key.value;
+        }
+        else if (prop.key.type === 'StringLiteral') {
+            keyName = prop.key.value;
+        }
+        const currentPath = path ? `${path}.${keyName}` : keyName;
+        if (prop.value.type === 'Identifier') {
+            const valueName = prop.value.value;
+            const stepInfo = stepDeclarations.get(valueName);
+            if (stepInfo) {
+                const nodeId = `node_${context.nodeCounter++}`;
+                const node = {
+                    id: nodeId,
+                    type: 'step',
+                    data: {
+                        label: `${getOriginalStepName(stepInfo.stepId, valueName)} (tool)`,
+                        nodeKind: 'step',
+                        stepId: stepInfo.stepId,
+                    },
+                    metadata: {
+                        isStepReference: true,
+                        referenceContext: currentPath,
+                    },
+                };
+                nodes.push(node);
+                entryNodeIds.push(nodeId);
+                exitNodeIds.push(nodeId);
+            }
+        }
+        if (prop.value.type === 'ObjectExpression') {
+            const nestedResult = analyzeObjectForStepReferences(prop.value, stepDeclarations, context, currentPath);
+            nodes.push(...nestedResult.nodes);
+            edges.push(...nestedResult.edges);
+            entryNodeIds.push(...nestedResult.entryNodeIds);
+            exitNodeIds.push(...nestedResult.exitNodeIds);
+        }
+    }
+    return { nodes, edges, entryNodeIds, exitNodeIds };
+}
+/**
+ * Analyze a transitive function call to find step calls within helper functions
+ */
+function analyzeTransitiveCall(funcName, stepDeclarations, context, functionMap, variableMap, visitedFunctions) {
+    const nodes = [];
+    const edges = [];
+    const entryNodeIds = [];
+    const exitNodeIds = [];
+    if (visitedFunctions.has(funcName)) {
+        return { nodes, edges, entryNodeIds, exitNodeIds };
+    }
+    const funcInfo = functionMap.get(funcName);
+    if (!funcInfo || funcInfo.isStep) {
+        return { nodes, edges, entryNodeIds, exitNodeIds };
+    }
+    visitedFunctions.add(funcName);
+    try {
+        if (funcInfo.body) {
+            if (funcInfo.body.type === 'BlockStatement') {
+                const bodyResult = analyzeBlock(funcInfo.body.stmts, stepDeclarations, context, functionMap, variableMap);
+                nodes.push(...bodyResult.nodes);
+                edges.push(...bodyResult.edges);
+                entryNodeIds.push(...bodyResult.entryNodeIds);
+                exitNodeIds.push(...bodyResult.exitNodeIds);
+            }
+            else {
+                const exprResult = analyzeExpression(funcInfo.body, stepDeclarations, context, functionMap, variableMap, visitedFunctions);
+                nodes.push(...exprResult.nodes);
+                edges.push(...exprResult.edges);
+                entryNodeIds.push(...exprResult.entryNodeIds);
+                exitNodeIds.push(...exprResult.exitNodeIds);
+            }
+        }
+    }
+    finally {
+        visitedFunctions.delete(funcName);
+    }
+    return { nodes, edges, entryNodeIds, exitNodeIds };
+}
+//# sourceMappingURL=workflows-extractor.js.map