flow-frame-core 0.1.0

package/dist/services/executor.js

@@ -0,0 +1,1587 @@
+import { runPrompt } from './runPrompt.js';
+import { getUtilityFunctions } from './utilityFunctions.js';
+import { NodeExecutionState } from './ModelContext.js';
+import { executeConfiguration, executeStep } from './configuration/executor.js';
+import FilterGmailPoller from '../filter-gmail-poller/filter-gmail-poller.js';
+import { safeExtractJSON } from '../jsonHandler.js';
+import { get, pause } from '../utils.js';
+import { MULTI_TASK_PROMPT_VALIDATION, POLLER_PROMPT_FILTER, validateMultiTaskPromptOutput } from '../filter-gmail-poller/poller-prompts.js';
+import { extractGmailBodyText } from '../email-body-extractor.js';
+import fs from 'fs';
+import path from 'path';
+import { createTaskConfig, DEFAULT_MODEL, runAutoPromptSearch } from './autoPromptOptimizer.js';
+import { fileToDataUrl } from './self-learning/image.js';
+import { KEYS } from '../constants.js';
+import { generateUIMap } from './uiMapService.js';
+import { StepByStepAiPlanner } from './stepByStepAiPlanner.js';
+import { UiMapPathFinder } from './uiMapPathFinder.js';
+import { executeChain } from './chainExecutor.js';
+export function computeExecutionOrder(nodes, edges) {
+    // Build a quick lookup of which node IDs actually exist
+    const nodeIds = new Set(nodes.map(n => n.id));
+    // 1a) Drop any edges whose source or target node has been removed
+    const validEdges = edges.filter(e => nodeIds.has(e.source) && nodeIds.has(e.target));
+    // ─── ORIGINAL STEPS, BUT USING validEdges ───────────────────────────────────
+    // 1b) Filter out the loop-back edges from the body back into the loop node
+    const acyclicEdges = validEdges.filter(e => e.targetHandle !== 'bodyIn');
+    // 2) Build indegree map & adjacency using only acyclicEdges
+    const indegree = new Map(nodes.map(n => [n.id, 0]));
+    const adj = new Map(nodes.map(n => [n.id, []]));
+    acyclicEdges.forEach(e => {
+        adj.get(e.source).push(e.target);
+        indegree.set(e.target, (indegree.get(e.target) || 0) + 1);
+    });
+    // 3) Initialize queue with zero-indegree nodes
+    const queue = Array.from(indegree.entries())
+        .filter(([, d]) => d === 0)
+        .map(([id]) => id);
+    // 4) Kahn’s algorithm
+    const sorted = [];
+    const nodeMap = new Map(nodes.map(n => [n.id, n]));
+    while (queue.length) {
+        const id = queue.shift();
+        // only push nodes that still exist
+        const node = nodeMap.get(id);
+        if (node)
+            sorted.push(node);
+        for (const nbr of adj.get(id) || []) {
+            indegree.set(nbr, indegree.get(nbr) - 1);
+            if (indegree.get(nbr) === 0) {
+                queue.push(nbr);
+            }
+        }
+    }
+    return sorted;
+}
+/**
+ * Returns the subgraph consisting of all nodes/edges reachable
+ * from startId, including startId itself.
+ */
+export function getSubgraph(startId, nodes, edges) {
+    if (!startId) {
+        return { nodes: [], edges: [] };
+    }
+    // 1️⃣ Start with the startId node itself
+    const seen = new Set([startId]);
+    const queue = [startId];
+    // 2️⃣ BFS to find all reachable nodes
+    while (queue.length) {
+        const id = queue.shift();
+        for (const e of edges) {
+            if (e.source === id && !seen.has(e.target)) {
+                seen.add(e.target);
+                queue.push(e.target);
+            }
+        }
+    }
+    // 3️⃣ Filter to only include reachable nodes & edges
+    const subNodes = nodes.filter((n) => seen.has(n.id));
+    const subEdges = edges.filter((e) => seen.has(e.source) && seen.has(e.target));
+    return { nodes: subNodes, edges: subEdges };
+}
+/**
+ * Extracts and parses the first JSON code‐fence in a string.
+ *
+ * @param {string} text  The text containing a ```json … ``` block.
+ * @returns {any}        The parsed JavaScript value.
+ * @throws {Error}      If no JSON fence is found or JSON is invalid.
+ */
+function extractJSONFrom(text) {
+    // This regex looks for ```json, then lazily captures everything up to the next ```
+    const fenceRE = /```json\s*([\s\S]*?)\s*```/i;
+    const match = text.match(fenceRE);
+    if (!match) {
+        try {
+            return JSON.parse(text);
+        }
+        catch (e) {
+            console.log(text);
+        }
+        throw new Error("No ```json … ``` block found");
+    }
+    const jsonString = match[1];
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (err) {
+        throw new Error("Invalid JSON inside code fence: " + err.message);
+    }
+}
+function saveNodeContext(ctx, inputs = {}) {
+    try {
+        const contextFile = path.join(process.cwd(), 'node_context.ndjson');
+        const contextEntry = {
+            timestamp: new Date().toISOString(),
+            context: ctx,
+            inputs: inputs
+        };
+        const jsonLine = JSON.stringify(contextEntry) + '\n';
+        fs.appendFileSync(contextFile, jsonLine);
+    }
+    catch (err) {
+        console.error('Error saving node context:', err);
+    }
+}
+function saveNodeValues(ctx, inputs = {}) {
+    try {
+        const valuesFile = path.join(process.cwd(), 'node_values.ndjson');
+        // Read existing values if file exists
+        let existingValues = new Map();
+        if (fs.existsSync(valuesFile)) {
+            const lines = fs.readFileSync(valuesFile, 'utf8').trim().split('\n');
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    existingValues.set(entry.nodeId, entry);
+                }
+                catch (e) {
+                    // Skip malformed lines
+                }
+            }
+        }
+        // Update with new values from ctx
+        for (const [nodeId, value] of Object.entries(ctx)) {
+            existingValues.set(nodeId, {
+                nodeId,
+                value,
+                input: inputs[nodeId],
+                timestamp: new Date().toISOString()
+            });
+        }
+        // Write all values back to file
+        const allEntries = Array.from(existingValues.values());
+        const content = allEntries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+        fs.writeFileSync(valuesFile, content);
+    }
+    catch (err) {
+        console.error('Error saving node values:', err);
+    }
+}
+export async function executeFlow(nodes, edges, workflows, modelContext, initialCtx = {}, callback, globalContext = {}) {
+    const sorted = computeExecutionOrder(nodes, edges);
+    const ctx = { ...initialCtx }; // start from seed
+    const inputs = {}; // Track inputs for each node
+    for (const node of sorted) {
+        const incoming = edges.find((e) => e.target === node.id);
+        const input = incoming ? ctx[incoming.source] : undefined;
+        const getHandleVal = (id) => {
+            const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+            if (e) {
+                let sourceNode = nodes.find(node => node.id === e.source);
+                if (ctx?.[e.source]) {
+                    return ctx?.[e.source];
+                }
+                else if (sourceNode && e.sourceHandle) {
+                    return sourceNode.data?.[e.sourceHandle];
+                }
+            }
+            return undefined;
+        };
+        // Store input for this node
+        inputs[node.id] = input;
+        try {
+            if (callback) {
+                callback(node.id, {
+                    state: NodeExecutionState.Running,
+                    message: `Executing ${node.type}...`
+                });
+            }
+            switch (node.type) {
+                case 'setNode': {
+                    const data = node.data;
+                    const key = data.key;
+                    let valueToSet = undefined;
+                    // If no value provided, try to get from input
+                    const inEdge = edges.find(e => e.target === node.id && e.targetHandle === 'in');
+                    if (inEdge) {
+                        valueToSet = ctx[inEdge.source];
+                    }
+                    else {
+                        valueToSet = input;
+                    }
+                    if (valueToSet === undefined) {
+                        valueToSet = data.value;
+                    }
+                    if (valueToSet === undefined) {
+                        throw new Error(`No value provided for SetNode ${node.id}`);
+                    }
+                    modelContext[key] = valueToSet;
+                    ctx[node.id] = valueToSet;
+                    break;
+                }
+                case 'getNode': {
+                    const data = node.data;
+                    const selectedKey = data.selectedKey;
+                    if (!selectedKey) {
+                        throw new Error(`No key selected for GetNode ${node.id}`);
+                    }
+                    const value = modelContext[selectedKey];
+                    ctx[node.id] = value;
+                    data.value = value;
+                    data.lastFetched = new Date().toISOString();
+                    break;
+                }
+                case 'promptNode': {
+                    const sysEdge = edges.find(e => e.target === node.id && e.targetHandle === 'system');
+                    const usrEdge = edges.find(e => e.target === node.id && e.targetHandle === 'user');
+                    const imgEdge = edges.find(e => e.target === node.id && e.targetHandle === 'images');
+                    const systemPrompt = sysEdge
+                        ? ctx[sysEdge.source]
+                        : node.data.systemPrompt;
+                    const userPrompt = usrEdge
+                        ? ctx[usrEdge.source]
+                        : node.data.userPrompt;
+                    let images = [];
+                    if (imgEdge) {
+                        const val = ctx[imgEdge.source];
+                        if (Array.isArray(val))
+                            images = val;
+                        else if (typeof val === 'string')
+                            images = val.split(',').map(s => s.trim()).filter(Boolean);
+                    }
+                    else if (node.data.images) {
+                        images = node.data.images.split(',').map(s => s.trim()).filter(Boolean);
+                    }
+                    // Convert file paths to data URLs
+                    const processedImages = images.map((img) => {
+                        if (img.startsWith('http://') || img.startsWith('https://') || img.startsWith('data:')) {
+                            return img;
+                        }
+                        try {
+                            return fileToDataUrl(img);
+                        }
+                        catch (e) {
+                            console.warn(`Could not convert image path to data URL: ${img}`, e.message);
+                            return img;
+                        }
+                    });
+                    // console.log(`System Prompt: ${systemPrompt}`);
+                    console.log(`User Prompt: ${userPrompt}`);
+                    const model = node.data.model;
+                    const fullPrompt = [
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userPrompt }
+                    ];
+                    const out = await runPrompt(fullPrompt, model, processedImages);
+                    // parse or raw
+                    try {
+                        ctx[node.id] = extractJSONFrom(out);
+                    }
+                    catch {
+                        ctx[node.id] = out;
+                    }
+                    break;
+                }
+                case 'switchNode': {
+                    const data = node.data;
+                    const switchValue = input;
+                    let matched = false;
+                    for (const switchCase of data.cases) {
+                        if (switchValue === switchCase.matchText) {
+                            let switchCaseValue = getHandleVal(`case-${switchCase.id}`);
+                            ctx[node.id] = switchCaseValue;
+                            matched = true;
+                            break;
+                        }
+                    }
+                    if (!matched) {
+                        ctx[node.id] = getHandleVal(`default`) || undefined;
+                    }
+                    break;
+                }
+                case 'propertyNode': {
+                    const obj = input;
+                    const path = node.data.property.split('.');
+                    ctx[node.id] = path.reduce((o, k) => o?.[k], obj);
+                    break;
+                }
+                case 'arrayItemNode': {
+                    const arr = input;
+                    const idx = node.data.index;
+                    ctx[node.id] = Array.isArray(arr) ? arr[idx] : undefined;
+                    break;
+                }
+                case 'inputArrayNode': {
+                    const data = node.data;
+                    let arr = data.parsed;
+                    if (!Array.isArray(arr)) {
+                        try {
+                            arr = extractJSONFrom(data.raw);
+                        }
+                        catch {
+                            arr = [];
+                        }
+                    }
+                    ctx[node.id] = arr;
+                    break;
+                }
+                case 'fetchNode': {
+                    // 1️⃣ Destructure new options
+                    const { url, method, responseType, timeoutMinutes = 10 } = node.data;
+                    // 2️⃣ Determine request body: manual or from "body" handle
+                    const bodyEdge = edges.find((e) => e.target === node.id && e.targetHandle === 'body');
+                    let requestBody = node.data.body;
+                    if (bodyEdge) {
+                        requestBody = ctx[bodyEdge.source];
+                    }
+                    try {
+                        // 3️⃣ Build RequestInit with method and optional body
+                        const init = { method };
+                        if (method !== 'GET' && method !== 'HEAD' && requestBody != null) {
+                            const bodyString = typeof requestBody === 'string'
+                                ? requestBody
+                                : JSON.stringify(requestBody);
+                            init.body = bodyString;
+                            init.headers = { 'Content-Type': 'application/json' };
+                        }
+                        // 4️⃣ Add timeout controller (configurable, default 10 minutes)
+                        const controller = new AbortController();
+                        const timeoutMs = (timeoutMinutes || 10) * 60 * 1000; // Convert minutes to milliseconds
+                        console.log(`Fetch timeout set to ${timeoutMs} ms for node ${node.id}`);
+                        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+                        init.signal = controller.signal;
+                        init.headersTimeout = 0; // Disable headers timeout to prevent premature failures
+                        // 5️⃣ Execute fetch and parse based on responseType
+                        const res = await fetch(modelContext.defaultServer + url, init);
+                        clearTimeout(timeoutId); // Clear timeout on success
+                        let val;
+                        if (responseType === 'json') {
+                            val = await res.json();
+                        }
+                        else {
+                            const text = await res.text();
+                            try {
+                                val = JSON.parse(text);
+                            }
+                            catch {
+                                val = text;
+                            }
+                        }
+                        // 6️⃣ Store result in context
+                        ctx[node.id] = val;
+                    }
+                    catch (err) {
+                        ctx[node.id] = undefined;
+                        // Handle timeout errors specifically
+                        if (err.name === 'AbortError') {
+                            throw new Error(`Fetch request timed out after ${timeoutMinutes || 10} minutes for URL: ${modelContext.defaultServer + url}`);
+                        }
+                        throw err;
+                    }
+                    break;
+                }
+                case 'pauseNode': {
+                    // Check for seconds input from handle
+                    const secondsEdge = edges.find((e) => e.target === node.id && e.targetHandle === 'seconds');
+                    let seconds = node.data.seconds || 0;
+                    if (secondsEdge) {
+                        const sourceValue = ctx[secondsEdge.source];
+                        if (typeof sourceValue === 'number') {
+                            seconds = sourceValue;
+                        }
+                        else if (typeof sourceValue === 'string') {
+                            seconds = parseInt(sourceValue, 10) || 0;
+                        }
+                    }
+                    console.log(`Pausing for ${seconds} seconds in node ${node.id}`);
+                    await new Promise(resolve => setTimeout(resolve, seconds * 1000));
+                    ctx[node.id] = input; // Pass through the input
+                    break;
+                }
+                case 'autoPromptOptimizerNode':
+                    {
+                        const getVal = (id) => {
+                            const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                            if (e) {
+                                let sourceNode = nodes.find(node => node.id === e.source);
+                                if (ctx?.[e.source]) {
+                                    return ctx?.[e.source];
+                                }
+                                else if (sourceNode && e.sourceHandle) {
+                                    return sourceNode.data?.[e.sourceHandle];
+                                }
+                            }
+                            return undefined;
+                        };
+                        const testConfig = createTaskConfig({
+                            name: getVal('name') || node.data.name || 'demo_email_extraction',
+                            taskDescription: getVal('taskDescription') || node.data.taskDescription || 'Extract a simple structured meeting request from an email body.',
+                            outputFormatDescription: getVal('outputFormatDescription') || node.data.outputFormatDescription || 'Return a JSON object with keys action, person, and datetime. Output ONLY JSON.',
+                            dataset: getVal('dataset') || node.data.dataset || []
+                        });
+                        const { bestPrompt, allResults } = await runAutoPromptSearch(testConfig, {
+                            maxIterations: getVal('maxIterations') || node.data.maxIterations || 5,
+                            promptsPerRound: getVal('promptsPerRound') || node.data.promptsPerRound || 10,
+                            topPromptsToFeedBack: getVal('topPromptsToFeedBack') || node.data.topPromptsToFeedBack || 3,
+                            model: getVal('model') || node.data.model || 'gpt-4'
+                        });
+                        ctx[node.id] = {
+                            bestPrompt,
+                            allResults
+                        };
+                    }
+                    break;
+                case 'gmailNode':
+                    {
+                        let poller = FilterGmailPoller.instance;
+                        if (poller) {
+                            // Set filter configuration before stepping through emails
+                            if (node.data.subjectPrefix) {
+                                console.log(`PollerNode: Setting filter configuration:`, node.data.subjectPrefix);
+                                await poller.updateFilterConfig({ subjectPrefix: node.data.subjectPrefix });
+                            }
+                            else {
+                                console.log(`PollerNode: Using existing filter configuration`);
+                            }
+                            if (node.data.labelNames && node.data.labelNames.length > 0) {
+                                console.log(`PollerNode: Setting label IDs:`, node.data.labelNames);
+                                await poller.updateFilterConfig({ labelNames: node.data.labelNames });
+                            }
+                            console.log(`PollerNode: Stepping through emails manually (not continuous polling)`);
+                            // Step through emails manually instead of continuous polling
+                            const emailResult = await poller.stepThroughEmails({
+                                maxResults: 10, // Process up to 10 emails at a time
+                                includeDetails: true // Get full email details
+                            });
+                            console.log(`Found ${emailResult.totalMessages} emails to process`);
+                            let emails = [];
+                            for (let email of emailResult.messages) {
+                                console.log(`Processing email: ${email.id}`);
+                                const emailBody = extractGmailBodyText(email);
+                                const subject = poller.getEmailSubject(email);
+                                emails.push({ id: email.id, body: emailBody, subject });
+                            }
+                            ctx[node.id] = emails;
+                        }
+                    }
+                    break;
+                case 'pollerNode': {
+                    let pollerNodeResults = [];
+                    console.log(`Executing PollerNode ${node.id}`);
+                    // PollerNode does not produce output directly, it will execute the nodes connected to it.
+                    const getVal = (id) => {
+                        const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                        if (e) {
+                            let sourceNode = nodes.find(node => node.id === e.source);
+                            if (ctx?.[e.source]) {
+                                return ctx?.[e.source];
+                            }
+                            else if (sourceNode && e.sourceHandle) {
+                                return sourceNode.data?.[e.sourceHandle];
+                            }
+                        }
+                        return undefined;
+                    };
+                    let poller = FilterGmailPoller.instance;
+                    const enableContinuous = node.data.enableContinuous;
+                    do {
+                        if (poller) {
+                            // Set filter configuration before stepping through emails
+                            if (node.data.subjectPrefix) {
+                                console.log(`PollerNode: Setting filter configuration:`, node.data.subjectPrefix);
+                                await poller.updateFilterConfig({ subjectPrefix: node.data.subjectPrefix });
+                            }
+                            else {
+                                console.log(`PollerNode: Using existing filter configuration`);
+                            }
+                            if (node.data.labelNames && node.data.labelNames.length > 0) {
+                                console.log(`PollerNode: Setting label IDs:`, node.data.labelNames);
+                                await poller.updateFilterConfig({ labelNames: node.data.labelNames });
+                            }
+                            console.log(`PollerNode: Stepping through emails manually (not continuous polling)`);
+                            // Step through emails manually instead of continuous polling
+                            const emailResult = await poller.stepThroughEmails({
+                                maxResults: 10, // Process up to 10 emails at a time
+                                includeDetails: true // Get full email details
+                            });
+                            console.log(`Found ${emailResult.totalMessages} emails to process`);
+                            for (let email of emailResult.messages) {
+                                console.log(`Processing email: ${email.id}`);
+                                const emailBody = extractGmailBodyText(email);
+                                const subject = poller.getEmailSubject(email);
+                                console.log('------------------------------ Email ------------------------------');
+                                console.log(emailBody);
+                                console.log('------------------------------ End ------------------------------');
+                                try {
+                                    const connectedLetters = [];
+                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').forEach((handle, index) => {
+                                        if (node?.data?.inputs) {
+                                            const entries = Object.entries(node.data.inputs);
+                                            if (entries) {
+                                                let temp = entries.find(([key, val]) => {
+                                                    return val?.label === handle;
+                                                });
+                                                const value = getVal(temp?.[0]);
+                                                const graph = temp?.[1]?.graph;
+                                                if (value !== undefined && graph) {
+                                                    ctx[node.id] = ctx[node.id] || {};
+                                                    ctx[node.id][handle] = value;
+                                                    connectedLetters.push({
+                                                        handle,
+                                                        input_id: temp?.[0],
+                                                        graph: graph
+                                                    });
+                                                }
+                                            }
+                                        }
+                                    });
+                                    // Now execute the subgraph for each connected letter
+                                    console.log(`PollerNode executing subgraph for letters:`);
+                                    let matchingOptions = [];
+                                    for (const cl of connectedLetters) {
+                                        const { handle, input_id, output_id } = cl;
+                                        const { text } = ctx[node.id][handle];
+                                        const fullPrompt = [
+                                            { role: 'system', content: POLLER_PROMPT_FILTER },
+                                            {
+                                                role: 'user',
+                                                content: JSON.stringify({
+                                                    email: `Subject: ${subject} \n\n Body: ${emailBody}`,
+                                                    taskDescription: text
+                                                })
+                                            }
+                                        ];
+                                        let res = await runPrompt(fullPrompt, node.data.llmModel || 'gpt-4');
+                                        let safeRes = safeExtractJSON(res);
+                                        if (safeRes) {
+                                            const { result, explanation } = safeRes;
+                                            console.log(`PollerNode ${handle} got result: ${result}`);
+                                            console.log(`PollerNode ${handle} got explanation: ${explanation}`);
+                                            if (result === 'MATCH') {
+                                                matchingOptions.push({
+                                                    letter: handle,
+                                                    result,
+                                                    explanation,
+                                                    text
+                                                });
+                                            }
+                                        }
+                                    }
+                                    if (matchingOptions.length > 1) {
+                                        let temp = {};
+                                        matchingOptions.forEach(mo => {
+                                            temp[mo.letter] = mo.text;
+                                        });
+                                        const checkMultiMatches = [
+                                            { role: 'system', content: MULTI_TASK_PROMPT_VALIDATION },
+                                            { role: 'user', content: JSON.stringify(temp) }
+                                        ];
+                                        let res = await runPrompt(checkMultiMatches, node.data.llmModel || 'gpt-4');
+                                        let safeRes = safeExtractJSON(res);
+                                        const { isValid, errors } = validateMultiTaskPromptOutput(safeRes, Object.keys(temp));
+                                        if (!isValid) {
+                                            console.error(`Multi-task prompt validation failed for email ${email.id}:`, errors);
+                                        }
+                                        else {
+                                            if (res?.decisions) {
+                                                matchingOptions = matchingOptions.filter(mo => res.decisions[mo.letter]);
+                                                console.log(`Filtered matching options: ${JSON.stringify(matchingOptions)} with multi-task validation ${JSON.stringify(res.decisions)}`);
+                                            }
+                                        }
+                                    }
+                                    if (matchingOptions.length > 0) {
+                                        // Execute selected graph
+                                        let { letter } = matchingOptions[0];
+                                        let connected = connectedLetters.find(x => x.handle === letter);
+                                        if (connected?.graph) {
+                                            console.log(`Executing graph: ${connected.graph} for letter ${letter}`);
+                                            // Load the graph configuration
+                                            const graphData = await fetch(modelContext.defaultServer + `/loadConfiguration?name=${encodeURIComponent(connected.graph)}`).then((r) => r.json());
+                                            if (graphData) {
+                                                const { nodes: graphNodes, edges: graphEdges } = graphData;
+                                                console.log(graphData);
+                                                // Inject the email data into the graph
+                                                const seedCtx = { email: { body: emailBody, subject }, item: { body: emailBody, subject } };
+                                                console.log('Executing subgraph with seedCtx:', seedCtx);
+                                                let res = await executeFlow(graphNodes, graphEdges, workflows, modelContext, seedCtx, callback, globalContext);
+                                                console.log(res);
+                                                pollerNodeResults.push(res);
+                                            }
+                                            else {
+                                                console.log(`Failed to load graph: ${connected.graph}`);
+                                            }
+                                        }
+                                        else {
+                                            throw new Error(`Connected letter ${letter} has no graph selected`);
+                                        }
+                                    }
+                                    else {
+                                        console.log(`PollerNode got no valid response for email ${email.id}`);
+                                    }
+                                    // After processing, move email to "processed" folder
+                                    if (node.data.removeEmails) {
+                                        // If removeEmails is true, delete the email instead of moving
+                                        await poller.moveEmailToFolder(email.id, 'processed');
+                                    }
+                                }
+                                catch (emailError) {
+                                    console.error(`Error processing email ${email.id}:`, emailError);
+                                    // Still try to move to processed folder even if processing failed
+                                    try {
+                                        if (node.data.removeEmails) {
+                                            // If removeEmails is true, delete the email instead of moving
+                                            await poller.moveEmailToFolder(email.id, 'processed');
+                                        }
+                                    }
+                                    catch (moveError) {
+                                        console.error(`Failed to move email ${email.id} to processed folder:`, moveError);
+                                    }
+                                }
+                            }
+                            console.log(`PollerNode completed processing ${emailResult.totalMessages} emails`);
+                        }
+                        await pause(() => {
+                            console.log(`Pausing for 10 seconds...`);
+                        }, 10000);
+                    } while (enableContinuous);
+                    ctx[node.id] = pollerNodeResults || [];
+                    break;
+                }
+                case 'smartAutomationNode':
+                    {
+                        // SmartAutomationNode executes a predefined smart automation workflow
+                        const getVal = (id) => {
+                            const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                            if (e) {
+                                let sourceNode = nodes.find(node => node.id === e.source);
+                                if (ctx?.[e.source]) {
+                                    return ctx?.[e.source];
+                                }
+                                else if (sourceNode && e.sourceHandle) {
+                                    return sourceNode.data?.[e.sourceHandle];
+                                }
+                            }
+                            return undefined;
+                        };
+                        const input = getVal('input');
+                        const automationName = node.data.workflow;
+                        const automationWorkflow = workflows.find(wf => {
+                            return wf.workflow.name === automationName || wf.workflow.id === automationName;
+                        });
+                        if (!automationWorkflow) {
+                            throw new Error(`Smart Automation workflow not found: ${automationName}`);
+                        }
+                        console.log(`Executing SmartAutomationNode ${node.id} with workflow ${automationName}`);
+                        let result = await executeConfiguration(automationWorkflow, node.data, ctx, { inputs: input }, workflows);
+                        console.log(`SmartAutomationNode ${node.id} executed automation ${automationName}:`, result);
+                        ctx[node.id] = result || {};
+                        break;
+                    }
+                    break;
+                case 'workflowNode': {
+                    // 1. Find input edges by handle id
+                    const getVal = (id) => {
+                        const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                        if (e) {
+                            let sourceNode = nodes.find(node => node.id === e.source);
+                            if (ctx?.[e.source]) {
+                                return ctx?.[e.source];
+                            }
+                            else if (sourceNode && e.sourceHandle) {
+                                return sourceNode.data?.[e.sourceHandle];
+                            }
+                        }
+                        return undefined;
+                    };
+                    const a = getVal('a'), b = getVal('b'), c = getVal('c');
+                    // 2. Get utility functions
+                    const workflow = workflows.find(wf => {
+                        console.log(wf);
+                        return wf.workflow.id === node.data.workflow || wf.workflow.id === node.data.workflowName;
+                    });
+                    if (!workflow) {
+                        console.log(`There are ${workflows.length} workflows loaded:`);
+                        console.log(workflows.map(d => `${d.workflow.id}=> ${d.workflow.name}`).join('\n'));
+                        throw new Error(`Workflow not found: ${node.data.workflow}`);
+                    }
+                    let result = await executeConfiguration(workflow, node.data, ctx, { a, b, c }, workflows);
+                    console.log(`WorkflowNode ${node.id} executed workflow ${node.data.workflow}:`, result);
+                    ctx[node.id] = result || {};
+                    break;
+                }
+                case 'uiPlannerExecNode':
+                    {
+                        // Takes the plan from a UiPlannerNode and executes the steps
+                        const getVal = (id) => {
+                            const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                            if (e) {
+                                let sourceNode = nodes.find(node => node.id === e.source);
+                                if (ctx?.[e.source]) {
+                                    return ctx?.[e.source];
+                                }
+                                else if (sourceNode && e.sourceHandle) {
+                                    return sourceNode.data?.[e.sourceHandle];
+                                }
+                            }
+                            return undefined;
+                        };
+                        const plan = getVal('plan');
+                        if (!plan || !Array.isArray(plan.steps)) {
+                            throw new Error(`Invalid plan input for UiPlannerExecNode ${node.id}`);
+                        }
+                        // Mock objects for executeStep compatibility
+                        const mockWorkflow = { id: 'ui-planner-exec', content: { id: 'ui-planner-exec' } };
+                        const mockJob = { id: 'exec' };
+                        const mockConfig = { version: 'exec' };
+                        const stepOutput = {};
+                        const results = [];
+                        for (const step of plan.steps) {
+                            console.log(`Executing plan step: ${step.description}`);
+                            try {
+                                await executeStep(mockWorkflow, mockJob, step, modelContext, // Global context/config
+                                { a: ctx }, // Inputs wrapper
+                                stepOutput, workflows, mockConfig);
+                                results.push({ step: step.description, status: 'completed' });
+                            }
+                            catch (error) {
+                                console.error(`Error executing step ${step.id}:`, error);
+                                results.push({ step: step.description, status: 'failed', error: error.message });
+                                throw error;
+                            }
+                        }
+                        ctx[node.id] = { planExecuted: true, results };
+                        break;
+                    }
+                    break;
+                case 'globalNode': {
+                    // 1. Find input edges by handle id
+                    const getVal = (id) => {
+                        const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                        if (e) {
+                            let sourceNode = nodes.find(node => node.id === e.source);
+                            if (ctx?.[e.source]) {
+                                return ctx?.[e.source];
+                            }
+                            else if (sourceNode && e.sourceHandle) {
+                                return sourceNode.data?.[e.sourceHandle];
+                            }
+                        }
+                        return undefined;
+                    };
+                    // 2. Process key-value pairs from node data
+                    const { pairs = [] } = node.data;
+                    // 3. Build global context object
+                    const globalData = {};
+                    for (const pair of pairs) {
+                        const { key, value, inputHandleId } = pair;
+                        if (inputHandleId) {
+                            // Get value from connected input
+                            const connectedValue = getVal(inputHandleId);
+                            globalData[key] = connectedValue !== undefined ? connectedValue : value;
+                        }
+                        else {
+                            // Use static value
+                            globalData[key] = value;
+                        }
+                    }
+                    // 4. Merge into global context
+                    Object.assign(globalContext, globalData);
+                    console.log(`Global Context updated in GlobalNode ${node.id}:`, globalContext);
+                    console.log(`Global Data set by GlobalNode ${node.id}:`, globalData);
+                    console.log(`node.data:`, node.data);
+                    // 5. Store result in local context for chaining
+                    ctx[node.id] = globalData;
+                    break;
+                }
+                case 'outputNode': {
+                    const inEdge = edges.find((e) => e.target === node.id);
+                    const payload = inEdge ? ctx[inEdge.source] : undefined;
+                    const { url, method } = node.data;
+                    try {
+                        await fetch(modelContext.defaultServer + url, {
+                            method: method || 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ ...node.data, data: payload, }),
+                        });
+                    }
+                    catch (err) {
+                        console.error(`Output node error:`, err);
+                        throw err;
+                    }
+                    break;
+                }
+                case 'inputNode': {
+                    // read the name from node.data, then read the context, 
+                    // and set the ctx with that value or the default value from the node.
+                    const data = node.data;
+                    console.log('InputNode context:');
+                    console.log(`data.name: ${data.name}`);
+                    console.log(ctx);
+                    ctx[node.id] = ctx[data.name] || data.value;
+                    data.value = ctx[node.id];
+                    console.log(`data.value: ${data.value}`);
+                    console.log(`InputNode ${node.id} set to:`, ctx[node.id]);
+                    break;
+                }
+                case 'graphNode': {
+                    {
+                        const arr = [input];
+                        console.log(`Executing GraphNode ${node.id}`);
+                        // inside executeFlow, case 'forLoopNode':
+                        console.log(input);
+                        const graphData = await fetch(modelContext.defaultServer + `/loadConfiguration?name=${encodeURIComponent(node.data.graph)}`).then((r) => r.json());
+                        const graph = graphData;
+                        if (!graph) {
+                            ctx[node.id] = [];
+                            break;
+                        }
+                        const { nodes: bodyNodes, edges: bodyEdges } = graph;
+                        const results = [];
+                        const item = arr[0];
+                        // 1️⃣ Before each iteration, inject into InputNodes:
+                        const seedCtx = { [`${node.id}.item`]: item };
+                        for (const subNode of bodyNodes) {
+                            if (subNode.type === 'inputNode') {
+                                const data = subNode.data;
+                                if (data.name === 'index') {
+                                    data.value = 0;
+                                    seedCtx[subNode.id] = 0;
+                                }
+                                else if (data.name === 'item') {
+                                    data.value = item;
+                                    seedCtx[subNode.id] = item;
+                                }
+                                else if (data.name === 'array') {
+                                    data.value = arr;
+                                    seedCtx[subNode.id] = arr;
+                                }
+                            }
+                        }
+                        if (callback) {
+                            callback(node.id, { progress: (1) / arr.length, state: NodeExecutionState.Running });
+                        }
+                        const bodyCtx = await executeFlow(bodyNodes, bodyEdges, workflows, modelContext, seedCtx, callback, globalContext);
+                        // find the ResultNode in bodyNodes
+                        const resultNode = bodyNodes.find((n) => n.type === 'resultNode');
+                        if (!resultNode) {
+                            console.warn(`No ResultNode found in loop body for node ${node.id}`);
+                            results.push(undefined);
+                        }
+                        else {
+                            // see if something fed into its 'in' handle
+                            const inEdge = bodyEdges.find(e => e.target === resultNode.id && e.targetHandle === 'in');
+                            const outVal = inEdge
+                                ? bodyCtx[inEdge.source]
+                                : resultNode.data.value;
+                            results.push(outVal);
+                        }
+                        ctx[node.id] = results[0];
+                        if (callback) {
+                            callback(node.id, { progress: (1) / arr.length, state: NodeExecutionState.Complete });
+                        }
+                    }
+                    break;
+                }
+                case 'ifNode': {
+                    const arr = [input];
+                    // inside executeFlow, case 'forLoopNode':
+                    const graph = input ? node.data.trueGraph : node.data.falseGraph;
+                    if (!graph) {
+                        ctx[node.id] = [];
+                        break;
+                    }
+                    const { nodes: bodyNodes, edges: bodyEdges } = graph;
+                    const results = [];
+                    const item = arr[0];
+                    // 1️⃣ Before each iteration, inject into InputNodes:
+                    const seedCtx = { [`${node.id}.item`]: item };
+                    for (const subNode of bodyNodes) {
+                        if (subNode.type === 'inputNode') {
+                            const data = subNode.data;
+                            if (data.name === 'index') {
+                                data.value = 0;
+                                seedCtx[subNode.id] = 0;
+                            }
+                            else if (data.name === 'item') {
+                                data.value = item;
+                                seedCtx[subNode.id] = item;
+                            }
+                            else if (data.name === 'array') {
+                                data.value = arr;
+                                seedCtx[subNode.id] = arr;
+                            }
+                        }
+                    }
+                    if (callback) {
+                        callback(node.id, { progress: (1) / arr.length });
+                    }
+                    const bodyCtx = await executeFlow(bodyNodes, bodyEdges, workflows, modelContext, seedCtx, callback, globalContext);
+                    // find the ResultNode in bodyNodes
+                    const resultNode = bodyNodes.find((n) => n.type === 'resultNode');
+                    if (!resultNode) {
+                        console.warn(`No ResultNode found in loop body for node ${node.id}`);
+                        results.push(undefined);
+                    }
+                    else {
+                        // see if something fed into its 'in' handle
+                        const inEdge = bodyEdges.find(e => e.target === resultNode.id && e.targetHandle === 'in');
+                        const outVal = inEdge
+                            ? bodyCtx[inEdge.source]
+                            : resultNode.data.value;
+                        results.push(outVal);
+                    }
+                    ctx[node.id] = results;
+                    break;
+                }
+                case 'ifWorkflowNode': {
+                    const conditionEdge = edges.find(e => e.target === node.id && e.targetHandle === 'condition');
+                    const inEdge = edges.find(e => e.target === node.id && e.targetHandle === 'in');
+                    const condition = conditionEdge
+                        ? ctx[conditionEdge.source]
+                        : node.data.condition;
+                    const inValues = inEdge
+                        ? ctx[inEdge.source]
+                        : undefined;
+                    console.log(`Executing ifWorkflowNode ${node.id} with node.data:`, node);
+                    console.log(`Condition value: ${condition}`);
+                    console.log(`Input values:`, inValues);
+                    // Determine which workflow to execute based on the input condition
+                    const workflowName = condition ? node.data.trueWorkflow : node.data.falseWorkflow;
+                    if (!workflowName) {
+                        console.warn(`No workflow selected for ${condition ? 'true' : 'false'} branch in ifWorkflowNode ${node.id}`);
+                        ctx[node.id] = undefined;
+                        break;
+                    }
+                    // Load the workflow configuration
+                    const graphData = await fetch(modelContext.defaultServer + `/loadConfiguration?name=${encodeURIComponent(workflowName || '')}`).then((r) => r.json());
+                    const graph = graphData;
+                    if (!graph) {
+                        console.error(`Workflow '${workflowName}' not found for ifWorkflowNode ${node.id}`);
+                        ctx[node.id] = undefined;
+                        break;
+                    }
+                    console.log(`Executing ${condition ? 'true' : 'false'} branch workflow: ${workflowName}`);
+                    const { nodes: bodyNodes, edges: bodyEdges } = graph;
+                    // Execute the workflow with the input as context
+                    const seedCtx = { [`${node.id}.condition`]: condition, item: inValues };
+                    // const bodyCtx = await executeFlow(bodyNodes, bodyEdges, workflows, modelContext, seedCtx, callback, globalContext);
+                    const bodyCtx = await executeFlow(bodyNodes, bodyEdges, workflows, modelContext, seedCtx, callback, globalContext);
+                    // Find the ResultNode in the workflow
+                    const resultNode = bodyNodes.find((n) => n.type === 'resultNode');
+                    if (!resultNode) {
+                        console.warn(`No ResultNode found in workflow ${workflowName} for ifWorkflowNode ${node.id}`);
+                        ctx[node.id] = undefined;
+                    }
+                    else {
+                        // Get the output from the ResultNode
+                        const inEdge = bodyEdges.find(e => e.target === resultNode.id && e.targetHandle === 'in');
+                        const outVal = inEdge
+                            ? bodyCtx[inEdge.source]
+                            : resultNode.data.value;
+                        ctx[node.id] = outVal;
+                    }
+                    break;
+                }
+                case 'ifGraphNode': { // similar to ifWorkflowNode but loads a automations
+                    const conditionEdge = edges.find(e => e.target === node.id && e.targetHandle === 'condition');
+                    const inputEdge = edges.find(e => e.target === node.id && e.targetHandle === 'input');
+                    const condition = conditionEdge
+                        ? ctx[conditionEdge.source]
+                        : node.data.condition;
+                    const inValues = inputEdge ? ctx[inputEdge.source] : undefined;
+                    console.log(`Executing ifGraphNode ${node.id} with node.data:`, node);
+                    console.log(`Condition value: ${condition}`);
+                    console.log(`Input values:`, inValues);
+                    // Determine which graph to execute based on the input condition
+                    const workflowId = condition ? node.data.trueAutomation : node.data.falseAutomation;
+                    const workflowName = condition ? node.data.trueAutomationName : node.data.falseAutomationName;
+                    if (!workflowId) {
+                        console.warn(`No automation selected for ${condition ? 'true' : 'false'} branch in ifGraphNode(automationNode) ${node.id}`);
+                        ctx[node.id] = undefined;
+                        throw new Error(`No automation selected for ${condition ? 'true' : 'false'} branch in ifGraphNode(automationNode) ${node.id}`);
+                    }
+                    console.log(`Executing ${condition ? 'true' : 'false'} branch graph: ${workflowId}`);
+                    // 2. Get utility functions
+                    const workflow = workflows.find(wf => {
+                        console.log(wf);
+                        return wf.workflow.id === workflowId || wf.workflow.id === workflowName;
+                    });
+                    if (!workflow) {
+                        console.log(`There are ${workflows.length} workflows loaded:`);
+                        console.log(workflows.map(d => `${d.workflow.id}=> ${d.workflow.name}`).join('\n'));
+                        throw new Error(`Workflow not found: ${workflowId}`);
+                    }
+                    let result = await executeConfiguration(workflow, node.data, ctx, { a: inValues, b: undefined, c: undefined }, workflows);
+                    ctx[node.id] = result;
+                    break;
+                }
+                case 'forEachNode':
+                    {
+                        const arr = Array.isArray(input) ? input : [];
+                        // Load the graph by ID instead of using embedded subnodes
+                        const graphName = node.data.graphNodeId;
+                        if (!graphName) {
+                            ctx[node.id] = [];
+                            break;
+                        }
+                        const graphData = await fetch(modelContext.defaultServer + `/loadConfiguration?name=${encodeURIComponent(graphName)}`).then((r) => r.json());
+                        const graph = graphData;
+                        if (!graph) {
+                            ctx[node.id] = [];
+                            break;
+                        }
+                        const { nodes: bodyNodes, edges: bodyEdges } = graph;
+                        const results = [];
+                        let max = arr.length;
+                        if (node.data.limitItems) {
+                            max = Math.min(node.data.limitCount || arr.length, arr.length);
+                        }
+                        for (let i = 0; i < max; i++) {
+                            const item = arr[i];
+                            // 1️⃣ Before each iteration, inject into InputNodes:
+                            const seedCtx = { [`${node.id}.item`]: item };
+                            for (const subNode of bodyNodes) {
+                                if (subNode.type === 'inputNode') {
+                                    const data = subNode.data;
+                                    if (data.name === 'index') {
+                                        data.value = i;
+                                        seedCtx[subNode.id] = i;
+                                    }
+                                    else if (data.name === 'item') {
+                                        data.value = item;
+                                        seedCtx[subNode.id] = item;
+                                    }
+                                    else if (data.name === 'array') {
+                                        data.value = arr;
+                                        seedCtx[subNode.id] = arr;
+                                    }
+                                }
+                            }
+                            if (callback) {
+                                callback(node.id, { state: NodeExecutionState.Running, message: `Executing loop iteration ${i + 1} of ${arr.length}` });
+                            }
+                            const bodyCtx = await executeFlow(bodyNodes, bodyEdges, workflows, modelContext, seedCtx, callback, globalContext);
+                            // find the ResultNode in bodyNodes
+                            const resultNode = bodyNodes.find((n) => n.type === 'resultNode');
+                            if (!resultNode) {
+                                console.warn(`No ResultNode found in loop body for node ${node.id}`);
+                                results.push(undefined);
+                            }
+                            else {
+                                // see if something fed into its 'in' handle
+                                const inEdge = bodyEdges.find(e => e.target === resultNode.id && e.targetHandle === 'in');
+                                const outVal = inEdge
+                                    ? bodyCtx[inEdge.source]
+                                    : resultNode.data.value;
+                                results.push(outVal);
+                            }
+                        }
+                        ctx[node.id] = results;
+                    }
+                    break;
+                case 'forLoopNode': {
+                    const arr = Array.isArray(input) ? input : [];
+                    // inside executeFlow, case 'forLoopNode':
+                    const bodyGraph = node.data.bodyGraph;
+                    if (!bodyGraph) {
+                        ctx[node.id] = [];
+                        break;
+                    }
+                    const { nodes: bodyNodes, edges: bodyEdges } = node.data.bodyGraph;
+                    const results = [];
+                    for (let i = 0; i < arr.length; i++) {
+                        const item = arr[i];
+                        // 1️⃣ Before each iteration, inject into InputNodes:
+                        const seedCtx = { [`${node.id}.item`]: item };
+                        for (const subNode of bodyNodes) {
+                            if (subNode.type === 'inputNode') {
+                                const data = subNode.data;
+                                if (data.name === 'index') {
+                                    data.value = i;
+                                    seedCtx[subNode.id] = i;
+                                }
+                                else if (data.name === 'item') {
+                                    data.value = item;
+                                    seedCtx[subNode.id] = item;
+                                }
+                                else if (data.name === 'array') {
+                                    data.value = arr;
+                                    seedCtx[subNode.id] = arr;
+                                }
+                            }
+                        }
+                        if (callback) {
+                            callback(node.id, { state: NodeExecutionState.Running, message: `Executing loop iteration ${i + 1} of ${arr.length}` });
+                        }
+                        const bodyCtx = await executeFlow(bodyNodes, bodyEdges, workflows, modelContext, seedCtx, callback, globalContext);
+                        // find the ResultNode in bodyNodes
+                        const resultNode = bodyNodes.find((n) => n.type === 'resultNode');
+                        if (!resultNode) {
+                            console.warn(`No ResultNode found in loop body for node ${node.id}`);
+                            results.push(undefined);
+                        }
+                        else {
+                            // see if something fed into its 'in' handle
+                            const inEdge = bodyEdges.find(e => e.target === resultNode.id && e.targetHandle === 'in');
+                            const outVal = inEdge
+                                ? bodyCtx[inEdge.source]
+                                : resultNode.data.value;
+                            results.push(outVal);
+                        }
+                    }
+                    ctx[node.id] = results;
+                    break;
+                }
+                case 'execJSNode': {
+                    // 1. Find input edges by handle id
+                    const getVal = (id) => {
+                        const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                        if (e) {
+                            let sourceNode = nodes.find(node => node.id === e.source);
+                            if (ctx?.[e.source]) {
+                                return ctx?.[e.source];
+                            }
+                            else if (sourceNode && e.sourceHandle) {
+                                return sourceNode.data?.[e.sourceHandle];
+                            }
+                        }
+                        return undefined;
+                    };
+                    let inputParams = 'abcdefg'.split('');
+                    let inputValues = inputParams.map(p => getVal(p));
+                    const { code } = node.data;
+                    // 2. Get utility functions
+                    const utils = { ...getUtilityFunctions(), fs, path };
+                    // 3. Build function with utilities available in scope
+                    const functionBody = `
+                        // Destructure utility functions for direct use
+
+                        const { 
+                            cleanJSONString,
+                            safeExtractJSON,
+                            containsJSON,
+                            extractMultipleJSON,
+                            extractJSON, capitalize, titleCase, slugify, truncate,
+                            chunk, unique, flatten, groupBy,
+                            pick, omit, deepMerge,
+                            formatDate, timeAgo,
+                            clamp, round, randomBetween, formatNumber,
+                            isEmail, isUrl, isEmpty,
+                            fetchJSON, delay, retry,
+                            template, log, inspect,
+                            fs, path
+                        } = utils;
+                        
+                        // Global context available
+                        const $global = ${JSON.stringify(globalContext)};
+                        
+                        // User code
+                        ${code || 'return undefined;'}
+                    `;
+                    console.log(`Global Context in ExecJSNode ${node.id}:`, globalContext);
+                    const fn = new Function(...inputParams, 'utils', 'global', functionBody);
+                    // 4. Execute and store result
+                    try {
+                        ctx[node.id] = await fn(...inputValues, utils, globalContext);
+                    }
+                    catch (err) {
+                        console.error(`ExecJSNode error:`, err);
+                        if (err && err.includes('[try again]')) {
+                            throw new Error(`ExecJSNode ${node.id} failed: ${err}`);
+                        }
+                        console.log(`Function body was:`, functionBody);
+                        ctx[node.id] = undefined;
+                    }
+                    node.data.output = ctx[node.id];
+                    console.log(`ExecJSNode ${node.id} output:`, ctx[node.id]);
+                    break;
+                }
+                case 'globalGetNode': {
+                    // 1. Find input edges by handle id
+                    const getVal = (id) => {
+                        const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                        if (e) {
+                            let sourceNode = nodes.find(node => node.id === e.source);
+                            if (ctx?.[e.source]) {
+                                return ctx[e.source];
+                            }
+                            else if (sourceNode?.data?.value !== undefined) {
+                                return sourceNode.data.value;
+                            }
+                        }
+                        return undefined;
+                    };
+                    // 2. Get key from input or node data
+                    let key = getVal('in'); // from 'in' handle
+                    if (key === undefined) {
+                        key = node.data.key; // from node data
+                    }
+                    // 3. Get default value from 'value' handle or node data
+                    let defaultValue = getVal('value'); // from 'value' handle
+                    if (defaultValue === undefined) {
+                        defaultValue = node.data.defaultValue; // from node data
+                    }
+                    // 4. Read from global context
+                    let result = undefined;
+                    if (key && typeof key === 'string' && globalContext) {
+                        // Support dot notation like 'user.name'
+                        const path = key.split('.');
+                        result = path.reduce((obj, k) => obj?.[k], globalContext);
+                    }
+                    // 5. Use default value if result is undefined
+                    if (result === undefined) {
+                        result = defaultValue;
+                    }
+                    // 6. Store result and update display
+                    ctx[node.id] = result;
+                    node.data.lastValue = result;
+                    break;
+                }
+                case 'resultNode': {
+                    const getVal = (id) => {
+                        const e = edges.find(e => e.target === node.id && e.targetHandle === id);
+                        if (e) {
+                            let node = nodes.find(node => node.id === e.source);
+                            if (ctx?.[e.source]) {
+                                return ctx?.[e.source];
+                            }
+                            else if (node && e.sourceHandle) {
+                                return node.data?.[e.sourceHandle];
+                            }
+                        }
+                        return undefined;
+                    };
+                    const a = getVal("in");
+                    ctx[node.id] = a;
+                    node.data.value = a;
+                    break;
+                }
+                case 'extensionNode': {
+                    const { extensionPath, capabilityId } = node.data;
+                    // 1. Fetch extensions list from API
+                    let extensions = [];
+                    try {
+                        const response = await fetch(`${modelContext.defaultServer}/get-extensions`);
+                        if (!response.ok)
+                            throw new Error(`Failed to fetch extensions: ${response.statusText}`);
+                        const data = await response.json();
+                        extensions = data.extensions || [];
+                    }
+                    catch (err) {
+                        console.error('Error fetching extensions:', err);
+                        throw new Error(`Could not retrieve extensions list: ${err.message}`);
+                    }
+                    // 2. Find the extension metadata
+                    const extensionMeta = extensions.find(ext => ext.location === extensionPath);
+                    if (!extensionMeta) {
+                        throw new Error(`Extension not found in registry: ${extensionPath}`);
+                    }
+                    // 3. Find the specific capability
+                    const capability = extensionMeta.capabilities?.find(cap => cap.id === capabilityId);
+                    if (!capability) {
+                        throw new Error(`Capability ${capabilityId} not found in extension ${extensionPath}`);
+                    }
+                    // 4. Resolve path and install dependencies
+                    let extensionFolders = [];
+                    try {
+                        const res = await fetch(`${modelContext.defaultServer}/getObject`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ key: 'extension_folders' })
+                        });
+                        if (res.ok) {
+                            const data = await res.json();
+                            extensionFolders = data.extension_folders || [];
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to fetch extension folders:', e);
+                    }
+                    let resolvedPath;
+                    const pathsToTry = [
+                        extensionPath,
+                        ...extensionFolders.map(folder => path.join(folder, extensionPath))
+                    ];
+                    for (const p of pathsToTry) {
+                        if (fs.existsSync(p)) {
+                            resolvedPath = p;
+                            break;
+                        }
+                    }
+                    if (!resolvedPath) {
+                        throw new Error(`Extension path not found. Checked: ${pathsToTry.join(', ')}`);
+                    }
+                    // Determine directory for installation
+                    const stat = fs.statSync(resolvedPath);
+                    const extensionDir = stat.isDirectory() ? resolvedPath : path.dirname(resolvedPath);
+                    // Install dependencies via API
+                    try {
+                        console.log(`Installing dependencies in ${extensionDir}...`);
+                        const installRes = await fetch(`${modelContext.defaultServer}/installDependencies`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ targetDir: extensionDir })
+                        });
+                        if (!installRes.ok) {
+                            console.warn(`Failed to install dependencies: ${installRes.statusText}`);
+                        }
+                        else {
+                            console.log(`Dependencies installed successfully.`);
+                        }
+                    }
+                    catch (e) {
+                        console.warn(`Error calling /installDependencies:`, e);
+                    }
+                    // 5. Execution handled via CLI, no need to import module in this process
+                    // let extensionModule; ...
+                    // Helper to get value from incoming edge
+                    const getVal = (targetHandleId) => {
+                        const edge = edges.find(e => e.target === node.id && e.targetHandle === targetHandleId);
+                        if (!edge)
+                            return undefined;
+                        // 1. Try execution context
+                        const sourceVal = ctx[edge.source];
+                        if (sourceVal !== undefined) {
+                            if (edge.sourceHandle && typeof sourceVal === 'object') {
+                                // Try exact match
+                                if (sourceVal[edge.sourceHandle] !== undefined)
+                                    return sourceVal[edge.sourceHandle];
+                                // Try stripping "output-" prefix
+                                const cleanHandle = edge.sourceHandle.replace(/^output-/, '');
+                                if (sourceVal[cleanHandle] !== undefined)
+                                    return sourceVal[cleanHandle];
+                            }
+                            return sourceVal;
+                        }
+                        // 2. Fallback to node data (for static values)
+                        const sourceNode = nodes.find(n => n.id === edge.source);
+                        if (sourceNode && edge.sourceHandle) {
+                            return sourceNode.data?.[edge.sourceHandle];
+                        }
+                        return undefined;
+                    };
+                    // Gather inputs defined in the capability
+                    const inputs = {};
+                    // 1. Map named inputs
+                    if (capability.inputs) {
+                        for (const inputDef of capability.inputs) {
+                            const handleId = `input-${inputDef.name}`;
+                            const val = getVal(handleId);
+                            if (val !== undefined) {
+                                inputs[inputDef.name] = val;
+                            }
+                        }
+                    }
+                    // 2. Check for generic "in" handle
+                    const genericIn = getVal('in');
+                    // if (genericIn !== undefined) {
+                    //     inputs['in'] = genericIn;
+                    // }
+                    console.log(`Executing extension node ${node.id} (${extensionPath}::${capabilityId}) via CLI`, inputs);
+                    // Execute via CLI endpoint
+                    const cliResponse = await fetch(`${modelContext.defaultServer}/runWorkflowCLI`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            targetDir: extensionDir,
+                            parameters: {
+                                ...inputs
+                            }
+                        })
+                    });
+                    if (!cliResponse.ok) {
+                        throw new Error(`CLI execution failed: ${cliResponse.statusText}`);
+                    }
+                    const cliResult = await cliResponse.json();
+                    if (cliResult.error) {
+                        throw new Error(`CLI execution error: ${cliResult.error}\nStderr: ${cliResult.stderr}`);
+                    }
+                    // Try to parse the output
+                    // let output = cliResult.stdout;
+                    // const extracted = safeExtractJSON(output);
+                    // if (extracted) {
+                    //     output = extracted;
+                    // }
+                    console.log(`Extension node ${node.id} CLI result:`, cliResult);
+                    // console.log(`Extension node ${node.id} output:`, output);
+                    ctx[node.id] = cliResult;
+                    node.data.output = cliResult;
+                    break;
+                }
+                case 'uiMapSelectorNode': {
+                    // For now, just pass through the input
+                    const { selectedFiles } = node.data;
+                    let workflow_folder = (get(KEYS.workflow_folder));
+                    // if the files are relative paths, make them absolute based on workflow_folder
+                    const absoluteFiles = selectedFiles.map(file => {
+                        if (!path.isAbsolute(file)) {
+                            return path.join(workflow_folder, file);
+                        }
+                        return file;
+                    });
+                    console.log(absoluteFiles);
+                    const uiMap = await generateUIMap(absoluteFiles);
+                    ctx[node.id] = { uiMap, files: absoluteFiles };
+                    node.data.output = { uiMap, files: absoluteFiles };
+                    break;
+                }
+                case 'uiMapProcessorNode': {
+                    // For now, just pass through the input
+                    ctx[node.id] = input;
+                    break;
+                }
+                case 'uiMapChatNode': {
+                    // For now, just pass through the input
+                    ctx[node.id] = node?.data?.generatedContext || '';
+                    break;
+                }
+                case 'uiDependencyGraphNode': {
+                    // For now, just pass through the input
+                    const { bodyGraph } = node.data;
+                    if (!bodyGraph) {
+                        throw new Error(`UiDependencyGraphNode ${node.id}: Missing required input (UI Map)`);
+                    }
+                    // 2. Parse UI Map
+                    let graph;
+                    try {
+                        graph = typeof bodyGraph === 'string' ? JSON.parse(bodyGraph) : bodyGraph;
+                    }
+                    catch (e) {
+                        throw new Error(`UiDependencyGraphNode ${node.id}: Invalid UI Map JSON - ${e.message}`);
+                    }
+                    ctx[node.id] = graph;
+                    node.data.output = graph;
+                    break;
+                }
+                case 'uiPlannerNode':
+                    {
+                        // 1. Resolve inputs
+                        const uiMapEdge = edges.find(e => e.target === node.id && e.targetHandle === 'uiMap');
+                        const contextEdge = edges.find(e => e.target === node.id && e.targetHandle === 'promptContext');
+                        const requestEdge = edges.find(e => e.target === node.id && e.targetHandle === 'userRequest');
+                        const dependencyGraphEdge = edges.find(e => e.target === node.id && e.targetHandle === 'dependencyGraph');
+                        const uiMapStr = uiMapEdge ? ctx[uiMapEdge.source] : node.data.uiMap;
+                        const promptContext = contextEdge ? ctx[contextEdge.source] : node.data.promptContext;
+                        const userRequest = requestEdge ? ctx[requestEdge.source] : node.data.userRequest;
+                        const dependencyGraph = dependencyGraphEdge ? ctx[dependencyGraphEdge.source] : node.data.dependencyGraph;
+                        if (!uiMapStr || !userRequest) {
+                            throw new Error(`UiPlannerNode ${node.id}: Missing required inputs (UI Map or User Request)`);
+                        }
+                        // 2. Parse UI Map
+                        let uiMapInput;
+                        try {
+                            uiMapInput = typeof uiMapStr === 'string' ? JSON.parse(uiMapStr) : uiMapStr;
+                        }
+                        catch (e) {
+                            throw new Error(`UiPlannerNode ${node.id}: Invalid UI Map JSON - ${e.message}`);
+                        }
+                        const uiMap = uiMapInput.uiMap || uiMapInput;
+                        const filePaths = uiMapInput.files || [];
+                        const automationFiles = [];
+                        if (filePaths.length > 0) {
+                            for (const filePath of filePaths) {
+                                try {
+                                    const content = await fs.promises.readFile(filePath, 'utf-8');
+                                    automationFiles.push({ path: filePath, content: JSON.parse(content) });
+                                }
+                                catch (err) {
+                                    console.warn(`UiPlannerNode: Failed to read automation file ${filePath}`, err);
+                                }
+                            }
+                        }
+                        // 3. Initialize Planner
+                        const pathFinder = new UiMapPathFinder(uiMap);
+                        // const planner = new UiPlanner(uiMap, pathFinder, {}, automationFiles);
+                        const planner = new StepByStepAiPlanner(uiMap, pathFinder, {}, automationFiles);
+                        // 4. Execute Plan
+                        const model = node.data.model || DEFAULT_MODEL;
+                        const context = { promptContext, dependencyGraph };
+                        // We assume startStateId is 'home' or passed in context if needed, 
+                        // but for now defaulting to 'home' as per UiPlanner default.
+                        // If the node had a 'startState' input, we could use that.
+                        const startStateId = 'home';
+                        console.log(`UiPlannerNode ${node.id} planning for request: "${userRequest}"`);
+                        const plan = await planner.plan(userRequest, startStateId, context, model);
+                        ctx[node.id] = plan;
+                    }
+                    break;
+                case 'promptFarmNode':
+                    {
+                        const promptLibIdEdge = edges.find(e => e.target === node.id && e.targetHandle === 'promptLibId');
+                        const chainIdEdge = edges.find(e => e.target === node.id && e.targetHandle === 'chainId');
+                        const promptLibId = promptLibIdEdge ? ctx[promptLibIdEdge.source] : node.data.promptLibId;
+                        const chainId = chainIdEdge ? ctx[chainIdEdge.source] : node.data.chainId;
+                        if (!promptLibId) {
+                            throw new Error(`PromptFarm node ${node.id}: Missing required input (Prompt Library ID)`);
+                        }
+                        // Fetch Lib
+                        const serverUrl = modelContext.defaultServer || 'http://localhost:3000';
+                        const safeLibId = promptLibId.replace(/\.prompt_lib$/, '');
+                        const libRes = await fetch(`${serverUrl}/api/prompt-libs/${safeLibId}`);
+                        if (!libRes.ok)
+                            throw new Error(`Failed to load Prompt Lib ${promptLibId}: ${libRes.statusText}`);
+                        const libJson = await libRes.json();
+                        const libData = libJson.promptLib || {};
+                        // Resolve Chain
+                        let targetChain = null;
+                        if (libData.executionTree && chainId) {
+                            // Support groupKey, or groupKey::resultKey
+                            const parts = chainId.split('::');
+                            const groupKey = parts[0];
+                            const resultKey = parts[1] || 'default';
+                            if (libData.executionTree[groupKey]) {
+                                targetChain = libData.executionTree[groupKey][resultKey];
+                            }
+                        }
+                        if (!targetChain) {
+                            // Fallback: Check if we have legacy format or just grab the first available
+                            if (!chainId && libData.executionTree) {
+                                const firstGroup = Object.keys(libData.executionTree)[0];
+                                if (firstGroup)
+                                    targetChain = libData.executionTree[firstGroup]['default'];
+                            }
+                        }
+                        if (!targetChain)
+                            throw new Error(`Chain not found: ${chainId || 'default'} in lib ${promptLibId}`);
+                        // Execute
+                        console.log(`Executing Prompt Chain: ${chainId} from ${promptLibId}`);
+                        const result = await executeChain({
+                            chainDef: targetChain,
+                            prompts: libData.prompts || {},
+                            input: input || node.data.input || '', // The incoming input to the node or manual input
+                            preamble: libData.preamble,
+                            precontext: libData.precontext,
+                            serverUrl,
+                            model: node.data.model || DEFAULT_MODEL,
+                            logFn: (msg) => {
+                                console.log(`[PromptFarm:${node.id}] ${msg}`);
+                                if (callback) {
+                                    callback(node.id, {
+                                        state: NodeExecutionState.Running,
+                                        message: msg
+                                    });
+                                }
+                            }
+                        });
+                        ctx[node.id] = result.result;
+                        // Store metadata for inspection
+                        node.data.executionHistory = result.history;
+                        node.data.output = result.result;
+                        break;
+                    }
+                default:
+                    break;
+            }
+            if (callback) {
+                callback(node.id, { state: NodeExecutionState.Complete });
+            }
+        }
+        catch (err) {
+            console.error(`Error executing node ${node.id}:`, err);
+            if (callback) {
+                callback(node.id, { state: NodeExecutionState.Error });
+            }
+            throw err;
+        }
+        // Save the cumulative context to file
+        saveNodeContext(ctx);
+        // Save individual node values (latest values across all executions)
+        saveNodeValues(ctx, inputs);
+    }
+    // Save the cumulative context to file
+    saveNodeContext(ctx);
+    // Save individual node values (latest values across all executions)
+    saveNodeValues(ctx, inputs);
+    return ctx;
+}
+//# sourceMappingURL=executor.js.map