@prompd/cli 0.4.9 → 0.4.11

package/dist/lib/workflowExecutor.js

@@ -3,6 +3,9 @@
  * WorkflowExecutor - Execute workflow graphs with sequential, conditional, and parallel support
  * Includes comprehensive execution tracing, debugging, and step-through capabilities
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeWorkflow = executeWorkflow;
 exports.createPromptExecutor = createPromptExecutor;
@@ -11,6 +14,11 @@ exports.exportTraceAsJson = exportTraceAsJson;
 exports.downloadTrace = downloadTrace;
 exports.formatTraceEntry = formatTraceEntry;
 exports.getTraceSummary = getTraceSummary;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const vm_1 = __importDefault(require("vm"));
 const workflowParser_1 = require("./workflowParser");
 const memoryBackend_1 = require("./memoryBackend");
 /**
@@ -639,8 +647,29 @@ async function executeWorkflow(workflow, params, options = {}) {
         message: `Starting workflow execution with ${executionOrder.length} nodes`,
         data: { executionOrder, mode: executionMode },
     }, options);
-    // Track previous output for auto-inject
+    // Track previous output for auto-inject (fallback for nodes with no incoming edges)
     let previousOutput = undefined;
+    // Build a predecessor map: for each node, find its graph predecessor(s) from incoming execution edges.
+    // This ensures previous_output resolves to the correct upstream node's output,
+    // not just the chronologically last-executed node (which breaks parallel branches).
+    const predecessorMap = new Map();
+    for (const edge of workflowFile.edges) {
+        // Only consider execution flow edges (same filtering as topological sort)
+        if (edge.sourceHandle === 'loop-end' || edge.sourceHandle === 'parallel-end')
+            continue;
+        if (edge.targetHandle && edge.targetHandle.startsWith('fork-'))
+            continue;
+        const eventBasedHandles = ['onError', 'onCheckpoint', 'onProgress', 'toolResult'];
+        if (edge.sourceHandle && eventBasedHandles.includes(edge.sourceHandle))
+            continue;
+        // Skip merge input handles — merge nodes have their own edge-based collection logic
+        if (edge.targetHandle && edge.targetHandle.startsWith('input-'))
+            continue;
+        if (!predecessorMap.has(edge.target)) {
+            predecessorMap.set(edge.target, []);
+        }
+        predecessorMap.get(edge.target).push(edge.source);
+    }
     // Track which nodes should be skipped due to condition branching
     // When a condition node evaluates, only the target branch should execute
     const skippedNodes = new Set();
@@ -771,247 +800,161 @@ async function executeWorkflow(workflow, params, options = {}) {
             state.nodeStates[nodeId].status = 'running';
             state.nodeStates[nodeId].startTime = nodeStartTime;
             options.onProgress?.(deepClone(state));
+            // Resolve previous_output from graph predecessor(s) instead of chronological last-executed node.
+            // This ensures nodes in parallel branches get the correct upstream output.
+            let resolvedPreviousOutput = previousOutput;
+            const predecessors = predecessorMap.get(nodeId);
+            if (predecessors && predecessors.length > 0) {
+                // Use the first predecessor that has a completed output
+                for (const predId of predecessors) {
+                    if (state.nodeOutputs[predId] !== undefined) {
+                        resolvedPreviousOutput = state.nodeOutputs[predId];
+                        break;
+                    }
+                }
+            }
             // Build context for expression evaluation
             const context = {
                 nodeOutputs: state.nodeOutputs,
                 variables: state.variables,
                 workflow: params,
-                previous_output: previousOutput,
+                previous_output: resolvedPreviousOutput,
             };
-            // Execute based on node type
-            let output;
-            switch (node.type) {
-                case 'prompt':
-                    output = await executePromptNode(node, context, options, trace, state, workflowFile);
-                    break;
-                case 'condition': {
-                    output = executeConditionNode(node, context);
-                    // Handle condition branching - mark non-selected branches as skipped
-                    const conditionOutput = output;
-                    const conditionInfo = branchingTargetMap.get(nodeId);
-                    if (conditionInfo) {
-                        // Determine which handle was selected
-                        // The branch ID maps to the handle ID: 'condition-{branchId}' or 'default'
-                        const selectedHandle = conditionOutput.branch === 'default'
-                            ? 'default'
-                            : `condition-${conditionOutput.branch}`;
-                        // Get the selected target from edges
-                        const selectedTarget = conditionInfo.edgeTargets.get(selectedHandle);
-                        // Find merge nodes that act as convergence points
-                        const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
-                        // For each non-selected branch, mark downstream nodes as skipped
-                        for (const [handleId, targetNodeId] of conditionInfo.edgeTargets) {
-                            if (handleId !== selectedHandle) {
-                                // Get all nodes downstream of this non-selected branch
-                                // Stop at merge nodes since those are where branches converge
-                                const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
-                                for (const skipNodeId of downstreamNodes) {
-                                    // Don't skip merge nodes - they may receive input from the selected branch
-                                    if (!mergeNodes.has(skipNodeId)) {
-                                        skippedNodes.add(skipNodeId);
-                                    }
+            // Execute node via shared dispatch (single source of truth for node type -> handler mapping)
+            let output = await dispatchNode(node, context, options, state, workflowFile, trace, memoryBackend, { executionOrder, branchingTargetMap, skippedNodes });
+            // ── Post-dispatch branching logic ──
+            // Certain node types produce branching outputs that determine which downstream
+            // paths should be skipped. This logic is main-loop-only (not needed in subset execution).
+            if (node.type === 'condition') {
+                const conditionOutput = output;
+                const conditionInfo = branchingTargetMap.get(nodeId);
+                if (conditionInfo) {
+                    const selectedHandle = conditionOutput.branch === 'default'
+                        ? 'default'
+                        : `condition-${conditionOutput.branch}`;
+                    const selectedTarget = conditionInfo.edgeTargets.get(selectedHandle);
+                    const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
+                    for (const [handleId, targetNodeId] of conditionInfo.edgeTargets) {
+                        if (handleId !== selectedHandle) {
+                            const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
+                            for (const skipNodeId of downstreamNodes) {
+                                if (!mergeNodes.has(skipNodeId)) {
+                                    skippedNodes.add(skipNodeId);
                                 }
-                                addTraceEntry(trace, {
-                                    type: 'debug_step',
-                                    nodeId,
-                                    message: `Skipping branch '${handleId}' (not selected), marking ${downstreamNodes.size} downstream nodes`,
-                                    data: { handleId, targetNodeId, skippedCount: downstreamNodes.size },
-                                }, options);
                             }
+                            addTraceEntry(trace, {
+                                type: 'debug_step',
+                                nodeId,
+                                message: `Skipping branch '${handleId}' (not selected), marking ${downstreamNodes.size} downstream nodes`,
+                                data: { handleId, targetNodeId, skippedCount: downstreamNodes.size },
+                            }, options);
                         }
-                        addTraceEntry(trace, {
-                            type: 'expression_eval',
-                            nodeId,
-                            nodeName: node.data.label,
-                            message: `Condition selected branch '${conditionOutput.branch}' -> target '${selectedTarget || 'none'}'`,
-                            data: { branch: conditionOutput.branch, target: selectedTarget, handle: selectedHandle },
-                        }, options);
-                    }
-                    break;
-                }
-                case 'loop':
-                    output = await executeLoopNode(node, context, options, state, workflowFile, trace, memoryBackend);
-                    break;
-                case 'parallel':
-                    output = await executeParallelNode(node, context, options, state, workflowFile, trace, memoryBackend);
-                    break;
-                case 'merge': {
-                    const mergeResult = executeMergeNode(node, context, workflowFile, skippedNodes);
-                    // Check if merge is waiting for more inputs
-                    if (mergeResult && typeof mergeResult === 'object' && 'waiting' in mergeResult && mergeResult.waiting) {
-                        // In wait mode, the merge node needs more inputs
-                        // This shouldn't happen with proper topological ordering, but handle it gracefully
-                        addTraceEntry(trace, {
-                            type: 'debug_step',
-                            nodeId,
-                            nodeName: node.data.label,
-                            message: `Merge node waiting for inputs: ${mergeResult.missingInputs.join(', ')}`,
-                            data: { missingInputs: mergeResult.missingInputs },
-                        }, options);
-                        // For now, proceed with empty result - proper handling would require reordering execution
-                        output = {};
-                    }
-                    else {
-                        output = mergeResult;
                     }
-                    break;
+                    addTraceEntry(trace, {
+                        type: 'expression_eval',
+                        nodeId,
+                        nodeName: node.data.label,
+                        message: `Condition selected branch '${conditionOutput.branch}' -> target '${selectedTarget || 'none'}'`,
+                        data: { branch: conditionOutput.branch, target: selectedTarget, handle: selectedHandle },
+                    }, options);
                 }
-                case 'transformer':
-                    output = executeTransformerNode(node, context);
-                    break;
-                case 'memory':
-                    output = await executeMemoryNode(node, context, state, memoryBackend);
-                    break;
-                case 'callback':
-                case 'checkpoint': // Alias for callback
-                    output = await executeCallbackNode(node, context, options, state, workflowFile, executionOrder, trace);
-                    break;
-                case 'user-input':
-                    output = await executeUserInputNode(node, context, options, trace);
-                    break;
-                case 'tool':
-                    output = await executeToolNode(node, context, options, trace);
-                    break;
-                case 'tool-call-parser': {
-                    output = executeToolCallParserNode(node, context, trace, options);
-                    // Handle branching based on whether a tool call was found
-                    const parserOutput = output;
-                    const parserInfo = branchingTargetMap.get(nodeId);
-                    if (parserInfo) {
-                        // Select handle based on hasToolCall result
-                        const selectedHandle = parserOutput.hasToolCall ? 'found' : 'not-found';
-                        const selectedTarget = parserInfo.edgeTargets.get(selectedHandle);
-                        // Find merge nodes that act as convergence points
-                        const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
-                        // For the non-selected branch, mark downstream nodes as skipped
-                        for (const [handleId, targetNodeId] of parserInfo.edgeTargets) {
-                            if (handleId !== selectedHandle) {
-                                const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
-                                for (const skipNodeId of downstreamNodes) {
-                                    if (!mergeNodes.has(skipNodeId)) {
-                                        skippedNodes.add(skipNodeId);
-                                    }
+            }
+            else if (node.type === 'tool-call-parser') {
+                const parserOutput = output;
+                const parserInfo = branchingTargetMap.get(nodeId);
+                if (parserInfo) {
+                    const selectedHandle = parserOutput.hasToolCall ? 'found' : 'not-found';
+                    const selectedTarget = parserInfo.edgeTargets.get(selectedHandle);
+                    const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
+                    for (const [handleId, targetNodeId] of parserInfo.edgeTargets) {
+                        if (handleId !== selectedHandle) {
+                            const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
+                            for (const skipNodeId of downstreamNodes) {
+                                if (!mergeNodes.has(skipNodeId)) {
+                                    skippedNodes.add(skipNodeId);
                                 }
-                                addTraceEntry(trace, {
-                                    type: 'debug_step',
-                                    nodeId,
-                                    message: `Skipping branch '${handleId}' (tool call ${parserOutput.hasToolCall ? 'found' : 'not found'}), marking ${downstreamNodes.size} downstream nodes`,
-                                    data: { handleId, targetNodeId, skippedCount: downstreamNodes.size },
-                                }, options);
                             }
+                            addTraceEntry(trace, {
+                                type: 'debug_step',
+                                nodeId,
+                                message: `Skipping branch '${handleId}' (tool call ${parserOutput.hasToolCall ? 'found' : 'not found'}), marking ${downstreamNodes.size} downstream nodes`,
+                                data: { handleId, targetNodeId, skippedCount: downstreamNodes.size },
+                            }, options);
                         }
-                        addTraceEntry(trace, {
-                            type: 'expression_eval',
-                            nodeId,
-                            nodeName: node.data.label,
-                            message: `Tool call parser: ${parserOutput.hasToolCall ? `found '${parserOutput.toolName}'` : 'no tool call'} -> ${selectedHandle}`,
-                            data: { hasToolCall: parserOutput.hasToolCall, toolName: parserOutput.toolName, selectedHandle, selectedTarget },
-                        }, options);
                     }
-                    break;
+                    addTraceEntry(trace, {
+                        type: 'expression_eval',
+                        nodeId,
+                        nodeName: node.data.label,
+                        message: `Tool call parser: ${parserOutput.hasToolCall ? `found '${parserOutput.toolName}'` : 'no tool call'} -> ${selectedHandle}`,
+                        data: { hasToolCall: parserOutput.hasToolCall, toolName: parserOutput.toolName, selectedHandle, selectedTarget },
+                    }, options);
                 }
-                case 'agent':
-                    output = await executeAgentNode(node, context, options, trace, state, workflowFile, memoryBackend);
-                    break;
-                case 'chat-agent': {
-                    output = await executeChatAgentNode(node, context, options, trace, state, workflowFile, branchingTargetMap, skippedNodes, memoryBackend);
-                    // Handle branching based on guardrail rejection (if guardrail is enabled)
-                    const chatAgentOutput = output;
-                    const chatAgentInfo = branchingTargetMap.get(nodeId);
-                    if (chatAgentInfo && chatAgentOutput?.rejected !== undefined) {
-                        const selectedHandle = chatAgentOutput.rejected ? 'rejected' : 'output';
-                        const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
-                        for (const [handleId, targetNodeId] of chatAgentInfo.edgeTargets) {
-                            if (handleId !== selectedHandle) {
-                                const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
-                                for (const skipNodeId of downstreamNodes) {
-                                    if (!mergeNodes.has(skipNodeId)) {
-                                        skippedNodes.add(skipNodeId);
-                                    }
+            }
+            else if (node.type === 'chat-agent') {
+                const chatAgentOutput = output;
+                const chatAgentInfo = branchingTargetMap.get(nodeId);
+                if (chatAgentInfo && chatAgentOutput?.rejected !== undefined) {
+                    const selectedHandle = chatAgentOutput.rejected ? 'rejected' : 'output';
+                    const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
+                    for (const [handleId, targetNodeId] of chatAgentInfo.edgeTargets) {
+                        if (handleId !== selectedHandle) {
+                            const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
+                            for (const skipNodeId of downstreamNodes) {
+                                if (!mergeNodes.has(skipNodeId)) {
+                                    skippedNodes.add(skipNodeId);
                                 }
                             }
                         }
                     }
-                    break;
                 }
-                case 'guardrail': {
-                    output = await executeGuardrailNode(node, context, options, trace, workflowFile);
-                    // Handle branching based on pass/reject result
-                    const guardrailOutput = output;
-                    const guardrailInfo = branchingTargetMap.get(nodeId);
-                    if (guardrailInfo) {
-                        // Select handle based on rejected result
-                        // If rejected, use 'rejected' handle; otherwise use 'output' handle
-                        const selectedHandle = guardrailOutput.rejected ? 'rejected' : 'output';
-                        const selectedTarget = guardrailInfo.edgeTargets.get(selectedHandle);
-                        // Find merge nodes that act as convergence points
-                        const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
-                        // For the non-selected branch, mark downstream nodes as skipped
-                        for (const [handleId, targetNodeId] of guardrailInfo.edgeTargets) {
-                            if (handleId !== selectedHandle) {
-                                const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
-                                for (const skipNodeId of downstreamNodes) {
-                                    if (!mergeNodes.has(skipNodeId)) {
-                                        skippedNodes.add(skipNodeId);
-                                    }
+            }
+            else if (node.type === 'guardrail') {
+                const guardrailOutput = output;
+                const guardrailInfo = branchingTargetMap.get(nodeId);
+                if (guardrailInfo) {
+                    const selectedHandle = guardrailOutput.rejected ? 'rejected' : 'output';
+                    const selectedTarget = guardrailInfo.edgeTargets.get(selectedHandle);
+                    const mergeNodes = findMergeNodesDownstream(nodeId, workflowFile);
+                    for (const [handleId, targetNodeId] of guardrailInfo.edgeTargets) {
+                        if (handleId !== selectedHandle) {
+                            const downstreamNodes = getDownstreamNodes(targetNodeId, workflowFile, mergeNodes);
+                            for (const skipNodeId of downstreamNodes) {
+                                if (!mergeNodes.has(skipNodeId)) {
+                                    skippedNodes.add(skipNodeId);
                                 }
-                                addTraceEntry(trace, {
-                                    type: 'debug_step',
-                                    nodeId,
-                                    message: `Skipping branch '${handleId}' (input ${guardrailOutput.rejected ? 'rejected' : 'passed'}), marking ${downstreamNodes.size} downstream nodes`,
-                                    data: { handleId, targetNodeId, skippedCount: downstreamNodes.size },
-                                }, options);
                             }
+                            addTraceEntry(trace, {
+                                type: 'debug_step',
+                                nodeId,
+                                message: `Skipping branch '${handleId}' (input ${guardrailOutput.rejected ? 'rejected' : 'passed'}), marking ${downstreamNodes.size} downstream nodes`,
+                                data: { handleId, targetNodeId, skippedCount: downstreamNodes.size },
+                            }, options);
                         }
-                        addTraceEntry(trace, {
-                            type: 'expression_eval',
-                            nodeId,
-                            nodeName: node.data.label,
-                            message: `Guardrail: input ${guardrailOutput.rejected ? 'rejected' : 'passed'}${guardrailOutput.score !== undefined ? ` (score: ${guardrailOutput.score})` : ''} -> ${selectedHandle}`,
-                            data: { rejected: guardrailOutput.rejected, score: guardrailOutput.score, selectedHandle, selectedTarget },
-                        }, options);
                     }
-                    break;
-                }
-                case 'command':
-                    output = await executeCommandNode(node, context, options, trace);
-                    break;
-                case 'web-search':
-                    output = await executeWebSearchNode(node, context, options, trace);
-                    break;
-                case 'claude-code':
-                    // Claude Code node - requires Electron for SSH support
                     addTraceEntry(trace, {
-                        type: 'debug_step',
+                        type: 'expression_eval',
                         nodeId,
                         nodeName: node.data.label,
-                        message: 'Claude Code node execution not yet implemented (requires Electron SSH)',
+                        message: `Guardrail: input ${guardrailOutput.rejected ? 'rejected' : 'passed'}${guardrailOutput.score !== undefined ? ` (score: ${guardrailOutput.score})` : ''} -> ${selectedHandle}`,
+                        data: { rejected: guardrailOutput.rejected, score: guardrailOutput.score, selectedHandle, selectedTarget },
                     }, options);
-                    output = previousOutput;
-                    break;
-                case 'workflow':
-                    // Sub-workflow node - recursive workflow execution
+                }
+            }
+            else if (node.type === 'merge') {
+                // Check if merge is waiting for more inputs
+                const mergeOut = output;
+                if (mergeOut && typeof mergeOut === 'object' && mergeOut.waiting) {
+                    const missingInputs = mergeOut.missingInputs || [];
                     addTraceEntry(trace, {
                         type: 'debug_step',
                         nodeId,
                         nodeName: node.data.label,
-                        message: 'Sub-workflow node execution not yet implemented',
+                        message: `Merge node waiting for inputs: ${missingInputs.join(', ')}`,
+                        data: { missingInputs },
                     }, options);
-                    output = previousOutput;
-                    break;
-                case 'mcp-tool':
-                    output = await executeMcpToolNode(node, context, options, trace);
-                    break;
-                case 'output':
-                    // Output node just passes through the previous output
-                    output = previousOutput;
-                    break;
-                case 'trigger':
-                    // Trigger node outputs the workflow parameters so downstream nodes can access them
-                    output = Object.keys(params).length > 0 ? params : previousOutput;
-                    break;
-                default:
-                    output = previousOutput;
+                    output = {};
+                }
             }
             const nodeDuration = Date.now() - nodeStartTime;
             // Store output
@@ -1246,9 +1189,10 @@ async function executePromptNode(node, context, options, trace, state, workflowF
         },
     };
     await emitAgentCheckpoint(afterEvent, options, workflowFile);
-    // Apply guardrail validation if configured
-    if (data.guardrail) {
+    // Apply guardrail validation if configured and enabled
+    if (data.guardrail && data.guardrail.enabled !== false) {
         const guardrail = data.guardrail;
+        const originalLlmResult = result; // Preserve LLM response before guardrail may modify it
         let isRejected = false;
         // Evaluate rejection condition
         if (guardrail.rejectionExpression) {
@@ -1333,8 +1277,8 @@ async function executePromptNode(node, context, options, trace, state, workflowF
                 message: `Guardrail PASSED content, outputMode=${outputMode}`,
             }, options);
             if (outputMode === 'original') {
-                // Return the original input that was sent to the guardrail prompt
-                result = context.previous_output;
+                // Return the original LLM response (before guardrail evaluation)
+                result = originalLlmResult;
             }
             else if (outputMode === 'reject-message') {
                 // Return custom message even on pass (useful for custom routing)
@@ -1610,6 +1554,82 @@ function executeConditionNode(node, context) {
     // Return default
     return { branch: 'default', target: data.default || '' };
 }
+/**
+ * Dispatch a single node for execution based on its type.
+ * This is the single source of truth for which function handles which node type.
+ * Both the main execution loop and executeNodeSubset call this to avoid
+ * duplicating the node-type switch statement.
+ *
+ * NOTE: This function handles pure execution only. Branching logic (condition,
+ * tool-call-parser, guardrail, chat-agent) that manipulates skippedNodes and
+ * branchingTargetMap is handled by the caller (main loop) after dispatch.
+ */
+async function dispatchNode(node, context, options, state, workflowFile, trace, memoryBackend, extra) {
+    const previousOutput = context.previous_output;
+    switch (node.type) {
+        case 'prompt':
+            return executePromptNode(node, context, options, trace, state, workflowFile);
+        case 'condition':
+            return executeConditionNode(node, context);
+        case 'loop':
+            return executeLoopNode(node, context, options, state, workflowFile, trace, memoryBackend);
+        case 'parallel':
+            return executeParallelNode(node, context, options, state, workflowFile, trace, memoryBackend, extra?.skippedNodes);
+        case 'merge':
+            return executeMergeNode(node, context, workflowFile, extra?.skippedNodes);
+        case 'transformer':
+            return executeTransformerNode(node, context);
+        case 'code':
+            return executeCodeNode(node, context);
+        case 'memory':
+            return executeMemoryNode(node, context, state, memoryBackend);
+        case 'callback':
+        case 'checkpoint':
+            return executeCallbackNode(node, context, options, state, workflowFile, extra?.executionOrder || [], trace);
+        case 'user-input':
+            return executeUserInputNode(node, context, options, trace);
+        case 'tool':
+            return executeToolNode(node, context, options, trace);
+        case 'tool-call-parser':
+            return executeToolCallParserNode(node, context, trace, options);
+        case 'agent':
+            return executeAgentNode(node, context, options, trace, state, workflowFile, memoryBackend);
+        case 'chat-agent':
+            return executeChatAgentNode(node, context, options, trace, state, workflowFile, extra?.branchingTargetMap || new Map(), extra?.skippedNodes || new Set(), memoryBackend);
+        case 'guardrail':
+            return executeGuardrailNode(node, context, options, trace, workflowFile);
+        case 'command':
+            return executeCommandNode(node, context, options, trace);
+        case 'web-search':
+            return executeWebSearchNode(node, context, options, trace);
+        case 'claude-code':
+            addTraceEntry(trace, {
+                type: 'debug_step',
+                nodeId: node.id,
+                nodeName: node.data.label,
+                message: 'Claude Code node execution not yet implemented (requires Electron SSH)',
+            }, options);
+            return previousOutput;
+        case 'workflow':
+            addTraceEntry(trace, {
+                type: 'debug_step',
+                nodeId: node.id,
+                nodeName: node.data.label,
+                message: 'Sub-workflow node execution not yet implemented',
+            }, options);
+            return previousOutput;
+        case 'mcp-tool':
+            return executeMcpToolNode(node, context, options, trace);
+        case 'output':
+            return previousOutput;
+        case 'trigger':
+            return Object.keys(context.workflow).length > 0 ? context.workflow : previousOutput;
+        case 'database-query':
+            return executeDatabaseQueryNode(node, context, options, trace);
+        default:
+            return previousOutput;
+    }
+}
 /**
  * Execute a subset of nodes (used by loop and parallel nodes)
  * Returns the output of the last executed node
@@ -1674,60 +1694,8 @@ async function executeNodeSubset(nodeIds, workflowFile, context, options, state,
                 workflow: context.workflow,
                 previous_output: lastOutput,
             };
-            // Execute based on node type
-            let output;
-            switch (node.type) {
-                case 'prompt':
-                    output = await executePromptNode(node, nodeContext, options, trace, state, workflowFile);
-                    break;
-                case 'condition':
-                    output = executeConditionNode(node, nodeContext);
-                    break;
-                case 'transformer':
-                    output = executeTransformerNode(node, nodeContext);
-                    break;
-                case 'memory':
-                    output = await executeMemoryNode(node, nodeContext, state, memoryBackend);
-                    break;
-                case 'merge':
-                    output = executeMergeNode(node, nodeContext);
-                    break;
-                case 'callback':
-                case 'checkpoint':
-                    // Execute callback node with full checkpoint support (pause, report, etc.)
-                    // Need to pass execution order for next node info - use nodeIds as the subset order
-                    output = await executeCallbackNode(node, nodeContext, options, state, workflowFile, nodeIds, trace);
-                    break;
-                case 'user-input':
-                    output = await executeUserInputNode(node, nodeContext, options, trace);
-                    break;
-                case 'command':
-                    output = await executeCommandNode(node, nodeContext, options, trace);
-                    break;
-                case 'web-search':
-                    output = await executeWebSearchNode(node, nodeContext, options, trace);
-                    break;
-                case 'mcp-tool':
-                    output = await executeMcpToolNode(node, nodeContext, options, trace);
-                    break;
-                case 'agent':
-                    output = await executeAgentNode(node, nodeContext, options, trace, state, workflowFile, memoryBackend);
-                    break;
-                case 'chat-agent':
-                    // Chat Agent uses a simplified context since branching is handled internally
-                    output = await executeChatAgentNode(node, nodeContext, options, trace, state, workflowFile, new Map(), // branchingTargetMap - not used in parallel execution
-                    new Set(), // skippedNodes - not used in parallel execution
-                    memoryBackend);
-                    break;
-                case 'guardrail':
-                    output = await executeGuardrailNode(node, nodeContext, options, trace, workflowFile);
-                    break;
-                case 'output':
-                    output = lastOutput;
-                    break;
-                default:
-                    output = lastOutput;
-            }
+            // Dispatch via shared single-source-of-truth switch
+            const output = await dispatchNode(node, nodeContext, options, state, workflowFile, trace, memoryBackend, { executionOrder: nodeIds });
             const nodeDuration = Date.now() - nodeStartTime;
             // Store output
             state.nodeOutputs[nodeId] = output;
@@ -1884,8 +1852,133 @@ async function executeLoopNode(node, context, options, state, workflowFile, trac
 /**
  * Execute a parallel node - executes all branches concurrently
  */
-async function executeParallelNode(node, context, options, state, workflowFile, trace, memoryBackend) {
+async function executeParallelNode(node, context, options, state, workflowFile, trace, memoryBackend, skippedNodes) {
     const data = node.data;
+    // ── Fork mode: edge-based parallelism ──
+    // In fork mode, the parallel node is NOT a container. It has fork-0, fork-1, etc.
+    // output handles that connect to downstream nodes. Each fork branch is traced
+    // forward through edges until reaching a merge node (or dead end), then all
+    // branches run concurrently via Promise.all.
+    if (data.mode === 'fork') {
+        // Find edges from this node's fork handles
+        const forkEdges = workflowFile.edges.filter(edge => edge.source === node.id && edge.sourceHandle?.startsWith('fork-'));
+        if (forkEdges.length === 0) {
+            addTraceEntry(trace, {
+                type: 'debug_step',
+                nodeId: node.id,
+                nodeName: node.data.label,
+                nodeType: 'parallel',
+                message: 'Fork mode: no fork edges found, passing through input',
+            }, options);
+            return context.previous_output;
+        }
+        // For each fork edge, trace the branch chain forward until a merge node or dead end
+        const forkBranches = [];
+        // Collect all merge node IDs so we know where to stop tracing
+        const mergeNodeIds = new Set(workflowFile.nodes.filter(n => n.type === 'merge').map(n => n.id));
+        for (const forkEdge of forkEdges) {
+            const branchNodeIds = [];
+            const visited = new Set();
+            const queue = [forkEdge.target];
+            while (queue.length > 0) {
+                const currentId = queue.shift();
+                if (visited.has(currentId) || mergeNodeIds.has(currentId))
+                    continue;
+                visited.add(currentId);
+                branchNodeIds.push(currentId);
+                // Follow outgoing execution edges from this node
+                for (const edge of workflowFile.edges) {
+                    if (edge.source !== currentId)
+                        continue;
+                    // Skip event-based and back-edges
+                    if (edge.sourceHandle === 'loop-end' || edge.sourceHandle === 'parallel-end')
+                        continue;
+                    if (edge.targetHandle?.startsWith('fork-'))
+                        continue;
+                    const eventHandles = ['onError', 'onCheckpoint', 'onProgress', 'toolResult'];
+                    if (edge.sourceHandle && eventHandles.includes(edge.sourceHandle))
+                        continue;
+                    // Skip edges going to merge input handles (that's the convergence point)
+                    if (edge.targetHandle?.startsWith('input-'))
+                        continue;
+                    if (!visited.has(edge.target) && !mergeNodeIds.has(edge.target)) {
+                        queue.push(edge.target);
+                    }
+                }
+            }
+            const handleIndex = forkEdge.sourceHandle?.replace('fork-', '') || '0';
+            const label = data.forkLabels?.[parseInt(handleIndex, 10)] || `Branch ${parseInt(handleIndex, 10) + 1}`;
+            forkBranches.push({ handle: forkEdge.sourceHandle || `fork-${handleIndex}`, label, nodeIds: branchNodeIds });
+        }
+        addTraceEntry(trace, {
+            type: 'debug_step',
+            nodeId: node.id,
+            nodeName: node.data.label,
+            nodeType: 'parallel',
+            message: `Fork mode: starting ${forkBranches.length} parallel branches (waitFor: ${data.waitFor})`,
+            data: {
+                branches: forkBranches.map(b => ({ handle: b.handle, label: b.label, nodeCount: b.nodeIds.length, nodes: b.nodeIds }))
+            },
+        }, options);
+        // Mark all fork branch nodes so the main loop skips them —
+        // they will be executed here concurrently instead of sequentially.
+        if (skippedNodes) {
+            for (const branch of forkBranches) {
+                for (const nid of branch.nodeIds) {
+                    skippedNodes.add(nid);
+                }
+            }
+        }
+        // Run all branches concurrently
+        const branchPromises = forkBranches.map(async (branch) => {
+            try {
+                const branchOutput = await executeNodeSubset(branch.nodeIds, workflowFile, { ...context, previous_output: context.previous_output }, options, state, trace, memoryBackend);
+                addTraceEntry(trace, {
+                    type: 'debug_step',
+                    nodeId: node.id,
+                    message: `Fork branch '${branch.label}' completed`,
+                    data: { handle: branch.handle, output: branchOutput },
+                }, options);
+                return { branchId: branch.label, result: branchOutput, success: true };
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                addTraceEntry(trace, {
+                    type: 'node_error',
+                    nodeId: node.id,
+                    message: `Fork branch '${branch.label}' failed: ${msg}`,
+                    data: { handle: branch.handle, error: msg },
+                }, options);
+                return { branchId: branch.label, result: null, success: false, error: msg };
+            }
+        });
+        // Wait based on strategy
+        let results;
+        if (data.waitFor === 'race') {
+            results = [await Promise.race(branchPromises)];
+        }
+        else if (data.waitFor === 'any') {
+            const all = await Promise.all(branchPromises);
+            const first = all.find(r => r.success);
+            results = first ? [first] : all;
+        }
+        else {
+            results = await Promise.all(branchPromises);
+        }
+        // Merge based on strategy
+        if (data.mergeStrategy === 'object') {
+            const merged = {};
+            for (const r of results)
+                merged[r.branchId] = r.result;
+            return merged;
+        }
+        if (data.mergeStrategy === 'first') {
+            const first = results.find(r => r.success);
+            return first ? { result: first.result } : { error: 'All branches failed' };
+        }
+        return results.map(r => r.result);
+    }
+    // ── Broadcast mode: container-based parallelism ──
     // Get child nodes from parentId relationship
     // Each child node becomes its own parallel "branch"
     const childNodeIds = getChildNodeIds(node.id, workflowFile, data);
@@ -2110,49 +2203,272 @@ function executeMergeNode(node, context, workflowFile, skippedNodes) {
     return merged;
 }
 /**
- * Execute a transformer node - applies JSON template transformation
+ * Execute a transformer node - applies data transformation via template or expression
+ *
+ * Modes:
+ * - template: JSON template with {{ variable }} interpolation (default)
+ * - expression: JavaScript expression evaluated via Function constructor
+ * - jq: Reserved for future JQ-style query support
  */
 function executeTransformerNode(node, context) {
     const data = node.data;
-    if (!data.transform) {
+    const mode = data.mode || 'template';
+    try {
+        if (mode === 'expression') {
+            return executeTransformerExpression(data, context);
+        }
+        // Template mode (default) — also handles legacy data.transform field
+        return executeTransformerTemplate(data, context);
+    }
+    catch (error) {
+        console.warn(`[TransformerNode] Transform error (mode=${mode}):`, error);
+        if (data.passthroughOnError) {
+            return context.previous_output;
+        }
+        throw error;
+    }
+}
+/**
+ * Execute transformer in template mode — JSON template with {{ }} variable interpolation
+ */
+function executeTransformerTemplate(data, context) {
+    // Support both new 'template' field and legacy 'transform' field
+    const transformTemplate = data.template || data.transform;
+    if (!transformTemplate) {
         return context.previous_output;
     }
-    // The transform is a JSON template string with {{ }} expressions
-    // We need to parse it and evaluate all expressions
+    // Find all {{ }} expressions and evaluate them
+    const expressionRegex = /\{\{([^}]+)\}\}/g;
+    const evaluatedTemplate = transformTemplate.replace(expressionRegex, (match) => {
+        const value = evaluateExpression(match, context);
+        // Convert to JSON-safe string representation
+        if (value === undefined || value === null) {
+            return 'null';
+        }
+        if (typeof value === 'string') {
+            // Escape for JSON string context
+            return JSON.stringify(value).slice(1, -1); // Remove surrounding quotes
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    });
+    // Try to parse the result as JSON
     try {
-        // First, try to parse as JSON with template replacements
-        let transformTemplate = data.transform;
-        // Find all {{ }} expressions and evaluate them
-        const expressionRegex = /\{\{([^}]+)\}\}/g;
-        const evaluatedTemplate = transformTemplate.replace(expressionRegex, (match) => {
-            const value = evaluateExpression(match, context);
-            // Convert to JSON-safe string representation
-            if (value === undefined || value === null) {
-                return 'null';
-            }
-            if (typeof value === 'string') {
-                // Escape for JSON string context - but we might be inside a JSON string already
-                // For safety, return the raw value and let JSON.parse handle it
-                return JSON.stringify(value).slice(1, -1); // Remove surrounding quotes
-            }
-            if (typeof value === 'object') {
-                return JSON.stringify(value);
-            }
-            return String(value);
+        return JSON.parse(evaluatedTemplate);
+    }
+    catch {
+        // If not valid JSON, return as string
+        return evaluatedTemplate;
+    }
+}
+/**
+ * Execute transformer in expression mode — JavaScript expression via Function constructor
+ *
+ * The expression has access to:
+ * - previous_output / input: output from the connected upstream node
+ * - Custom inputVariable name (defaults to 'input')
+ * - workflow: workflow parameters
+ * - All node outputs by node ID
+ */
+function executeTransformerExpression(data, context) {
+    const expression = data.expression;
+    if (!expression) {
+        return context.previous_output;
+    }
+    const inputVarName = data.inputVariable || 'input';
+    // Build the execution context with all available variables.
+    // Node output keys (e.g. "web-search-1770610749352") contain hyphens which are not
+    // valid JS identifiers. We sanitize them (hyphens -> underscores) so they can be
+    // used as Function parameter names. Node labels are also added as aliases.
+    const execContext = {};
+    // Add node outputs with sanitized keys and label-based aliases
+    for (const [key, value] of Object.entries(context.nodeOutputs)) {
+        const sanitized = key.replace(/[^a-zA-Z0-9_$]/g, '_');
+        execContext[sanitized] = value;
+    }
+    // Add workflow variables (these should already be valid identifiers)
+    for (const [key, value] of Object.entries(context.variables)) {
+        execContext[key] = value;
+    }
+    execContext.workflow = context.workflow;
+    execContext.previous_output = context.previous_output;
+    execContext.input = context.previous_output;
+    execContext.previous_step = context.previous_output;
+    // Also set the custom inputVariable name
+    if (inputVarName !== 'input' && inputVarName !== 'previous_output') {
+        execContext[inputVarName] = context.previous_output;
+    }
+    // Build parameter names and values for the Function constructor
+    const paramNames = Object.keys(execContext);
+    const paramValues = Object.values(execContext);
+    // Wrap the expression in a function body that supports multi-line code with return
+    // eslint-disable-next-line no-new-func
+    const fn = new Function(...paramNames, expression);
+    return fn(...paramValues);
+}
+/**
+ * Execute code in a sandboxed context.
+ *
+ * - TS/JS: new Function() with context variables injected as parameters
+ * - Python: Writes a temp .py file, passes input as JSON via stdin, reads JSON output
+ * - C#: Writes a temp .csx file for dotnet-script, same stdin/stdout JSON pattern
+ *
+ * For Python/C#, the previous node's output is serialized as JSON and passed via
+ * stdin. The script must print its result as JSON to stdout.
+ */
+function executeInlineCode(code, language, inputVarName, timeoutMs, nodeLabel, nodeId, context, executionContext = 'isolated') {
+    if (!code) {
+        return context.previous_output;
+    }
+    // TS/JS: execute via vm (isolated) or Function constructor (main)
+    if (language === 'typescript' || language === 'javascript') {
+        const execVars = {};
+        // Sanitize node output keys — node IDs contain hyphens (e.g. "web-search-...")
+        // which are not valid JS identifiers for Function constructor params
+        for (const [key, value] of Object.entries(context.nodeOutputs)) {
+            execVars[key.replace(/[^a-zA-Z0-9_$]/g, '_')] = value;
+        }
+        for (const [key, value] of Object.entries(context.variables)) {
+            execVars[key] = value;
+        }
+        execVars.workflow = context.workflow;
+        execVars.previous_output = context.previous_output;
+        execVars.input = context.previous_output;
+        execVars.previous_step = context.previous_output;
+        if (inputVarName !== 'input' && inputVarName !== 'previous_output') {
+            execVars[inputVarName] = context.previous_output;
+        }
+        if (executionContext === 'isolated') {
+            // Sandboxed execution via Node.js vm module — no access to require, process, etc.
+            const sandbox = {
+                ...execVars,
+                console: { log: console.log, warn: console.warn, error: console.error },
+                JSON,
+                Math,
+                Date,
+                Array,
+                Object,
+                String,
+                Number,
+                Boolean,
+                RegExp,
+                Map,
+                Set,
+                Promise,
+                parseInt,
+                parseFloat,
+                isNaN,
+                isFinite,
+                encodeURIComponent,
+                decodeURIComponent,
+                encodeURI,
+                decodeURI,
+            };
+            const vmContext = vm_1.default.createContext(sandbox);
+            // Wrap in an async IIFE so user code can use return statements
+            const wrapped = `(function() {\n${code}\n})()`;
+            const script = new vm_1.default.Script(wrapped, { filename: `${nodeLabel}.js` });
+            return script.runInContext(vmContext, { timeout: timeoutMs });
+        }
+        // Main context — full access via Function constructor
+        const paramNames = Object.keys(execVars);
+        const paramValues = Object.values(execVars);
+        // eslint-disable-next-line no-new-func
+        const fn = new Function(...paramNames, code);
+        return fn(...paramValues);
+    }
+    // Python: pass code via -c flag, input data via stdin as JSON
+    if (language === 'python') {
+        const inputJson = JSON.stringify(context.previous_output ?? null);
+        // Wrap user code in a function so 'return' works, pipe input via stdin
+        const wrapper = [
+            'import sys, json',
+            `${inputVarName} = json.loads(sys.stdin.read())`,
+            'workflow = json.loads(' + JSON.stringify(JSON.stringify(context.workflow)) + ')',
+            'def __user_fn__():',
+            ...code.split('\n').map(line => '  ' + line),
+            '__result__ = __user_fn__()',
+            'if __result__ is not None:',
+            '  print(json.dumps(__result__))',
+        ].join('\n');
+        // execFileSync bypasses shell — args passed directly to process, no escaping needed
+        const stdout = (0, child_process_1.execFileSync)('python', ['-c', wrapper], {
+            input: inputJson,
+            encoding: 'utf-8',
+            timeout: timeoutMs,
+            windowsHide: true,
         });
-        // Try to parse the result as JSON
+        const trimmed = stdout.trim();
+        if (!trimmed)
+            return context.previous_output;
         try {
-            return JSON.parse(evaluatedTemplate);
+            return JSON.parse(trimmed);
         }
         catch {
-            // If not valid JSON, return as string
-            return evaluatedTemplate;
+            return trimmed;
+        }
+    }
+    // C#: write temp .cs file, run via `dotnet <file>.cs` (.NET 10 file-based programs)
+    // Uses System.Text.Json (built-in, no external NuGet needed) for JSON serialization
+    if (language === 'csharp') {
+        const inputJson = JSON.stringify(context.previous_output ?? null);
+        const wrapper = [
+            'using System;',
+            'using System.IO;',
+            'using System.Text.Json;',
+            'using System.Text.Json.Nodes;',
+            '',
+            `var ${inputVarName} = JsonNode.Parse(Console.In.ReadToEnd());`,
+            'var workflow = JsonNode.Parse(' + JSON.stringify(JSON.stringify(context.workflow)) + ');',
+            '',
+            code,
+        ].join('\n');
+        const tempDir = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'prompd-code-'));
+        const tempFile = (0, path_1.join)(tempDir, 'script.cs');
+        try {
+            (0, fs_1.writeFileSync)(tempFile, wrapper, 'utf-8');
+            const stdout = (0, child_process_1.execFileSync)('dotnet', ['run', tempFile], {
+                input: inputJson,
+                encoding: 'utf-8',
+                timeout: timeoutMs,
+                windowsHide: true,
+            });
+            const trimmed = stdout.trim();
+            if (!trimmed)
+                return context.previous_output;
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch {
+                return trimmed;
+            }
+        }
+        finally {
+            try {
+                (0, fs_1.unlinkSync)(tempFile);
+            }
+            catch { /* ignore cleanup errors */ }
         }
     }
-    catch (error) {
-        console.warn(`[TransformerNode] Transform error:`, error);
-        return context.previous_output;
-    }
+    throw new Error(`Unsupported code language '${language}'.\n` +
+        `Supported: typescript, javascript, python, csharp.\n` +
+        `Node: "${nodeLabel}" (${nodeId})`);
+}
+/**
+ * Execute a code node — dispatches to executeInlineCode with CodeNodeData fields.
+ */
+function executeCodeNode(node, context) {
+    const data = node.data;
+    return executeInlineCode(data.code, data.language || 'javascript', data.inputVariable || 'input', data.timeoutMs ?? 30000, node.data.label, node.id, context, data.executionContext || 'isolated');
+}
+/**
+ * Execute code from a ToolNode with toolType 'code'.
+ * Same pattern as executeCodeNode but reads from ToolNodeData's code fields.
+ */
+function executeToolCodeSnippet(data, node, context) {
+    return executeInlineCode(data.codeSnippet || '', data.codeLanguage || 'javascript', data.codeInputVariable || 'input', 30000, node.data.label, node.id, context, data.codeExecutionContext || 'isolated');
 }
 /**
  * Execute a memory node - KV store, conversation history, or cache operations
@@ -2849,6 +3165,111 @@ async function executeWebSearchNode(node, context, options, trace) {
         };
     }
 }
+/**
+ * Execute a database query node - delegates to IPC via onToolCall
+ *
+ * Resolves the connection from the workflow's connections array to determine
+ * the database type, then sends a ToolCallRequest with databaseConfig.
+ * The actual DB driver execution happens in the Electron main process.
+ */
+async function executeDatabaseQueryNode(node, context, options, trace) {
+    const data = node.data;
+    // Resolve query template if it contains expressions
+    let resolvedQuery = data.query || '';
+    if (resolvedQuery.includes('{{')) {
+        const result = evaluateExpression(resolvedQuery, context);
+        resolvedQuery = typeof result === 'string' ? result : String(result);
+    }
+    // Resolve parameters template if present
+    let resolvedParameters = data.parameters || '';
+    if (resolvedParameters.includes('{{')) {
+        const result = evaluateExpression(resolvedParameters, context);
+        resolvedParameters = typeof result === 'string' ? result : String(result);
+    }
+    // Resolve collection template if present (MongoDB)
+    let resolvedCollection = data.collection || '';
+    if (resolvedCollection.includes('{{')) {
+        const result = evaluateExpression(resolvedCollection, context);
+        resolvedCollection = typeof result === 'string' ? result : String(result);
+    }
+    addTraceEntry(trace, {
+        type: 'debug_step',
+        nodeId: node.id,
+        nodeName: node.data.label,
+        nodeType: 'database-query',
+        message: `Executing ${data.queryType || 'select'} query`,
+        data: {
+            connectionId: data.connectionId,
+            queryType: data.queryType,
+            query: resolvedQuery.length > 100 ? resolvedQuery.slice(0, 100) + '...' : resolvedQuery,
+            collection: resolvedCollection || undefined,
+        },
+    }, options);
+    if (options.onToolCall) {
+        try {
+            // dbType is resolved by the IPC handler (main.js) from the connection config.
+            // We do not hardcode it here — the connection's dbType is the source of truth.
+            const toolCallRequest = {
+                nodeId: node.id,
+                toolName: 'database-query',
+                toolType: 'database-query',
+                parameters: {},
+                databaseConfig: {
+                    connectionId: data.connectionId,
+                    queryType: data.queryType || 'select',
+                    query: resolvedQuery,
+                    parameters: resolvedParameters || undefined,
+                    collection: resolvedCollection || undefined,
+                    maxRows: data.maxRows ?? 1000,
+                    timeoutMs: data.timeoutMs ?? 30000,
+                },
+            };
+            const result = await options.onToolCall(toolCallRequest);
+            if (!result.success) {
+                throw new Error(result.error || 'Database query failed');
+            }
+            addTraceEntry(trace, {
+                type: 'debug_step',
+                nodeId: node.id,
+                nodeName: node.data.label,
+                nodeType: 'database-query',
+                message: 'Database query completed successfully',
+                data: {
+                    rowCount: Array.isArray(result.result) ? result.result.length : 1,
+                },
+            }, options);
+            return result.result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            addTraceEntry(trace, {
+                type: 'node_error',
+                nodeId: node.id,
+                nodeName: node.data.label,
+                nodeType: 'database-query',
+                message: `Database query error: ${errorMessage}`,
+                data: { error: errorMessage },
+            }, options);
+            throw error;
+        }
+    }
+    else {
+        addTraceEntry(trace, {
+            type: 'debug_step',
+            nodeId: node.id,
+            nodeName: node.data.label,
+            nodeType: 'database-query',
+            message: 'Database query requires onToolCall callback',
+            data: { connectionId: data.connectionId, query: resolvedQuery },
+        }, options);
+        return {
+            skipped: true,
+            reason: 'onToolCall callback required for database query execution',
+            connectionId: data.connectionId,
+            queryType: data.queryType,
+        };
+    }
+}
 /**
  * Execute an MCP tool node - calls external MCP server tools
  */
@@ -3041,6 +3462,39 @@ async function executeToolNode(node, context, options, trace) {
             serverName: data.mcpServerName,
         };
     }
+    // Code tools execute directly via Function constructor — no callback needed
+    if (data.toolType === 'code') {
+        try {
+            const result = executeToolCodeSnippet(data, node, context);
+            addTraceEntry(trace, {
+                type: 'node_complete',
+                nodeId: node.id,
+                nodeName: node.data.label,
+                nodeType: 'tool',
+                message: `Code tool completed: ${toolNameDisplay}`,
+                data: {
+                    toolName: data.toolName || '',
+                    toolNameDisplay,
+                    toolType: 'code',
+                    nodeLabel: node.data.label,
+                    result
+                },
+            }, options);
+            // Apply output transform if defined
+            if (data.outputTransform) {
+                return evaluateExpression(data.outputTransform, {
+                    ...context,
+                    nodeOutputs: { ...context.nodeOutputs, result },
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Code tool '${toolNameDisplay}' failed: ${errorMessage}\n` +
+                `Node: "${node.data.label}" (${node.id})`);
+        }
+    }
     // If no callback is provided, we can't execute the tool
     if (!options.onToolCall) {
         // For HTTP tools, we can execute directly
@@ -3649,6 +4103,10 @@ async function executeAgentNode(node, context, options, trace, state, workflowFi
         const lastAssistantMessage = conversationHistory.filter(m => m.role === 'assistant').pop();
         finalResponse = lastAssistantMessage?.content || 'Agent reached maximum iterations without completing.';
     }
+    // Strip any unexecuted <tool_call> XML from final response so raw tags don't leak to output
+    if (finalResponse) {
+        finalResponse = finalResponse.replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '').trim();
+    }
     // Determine output based on outputMode
     let output;
     switch (data.outputMode) {
@@ -4659,6 +5117,10 @@ Analyze the input above. Return a JSON object:
         const lastAssistantMessage = conversationHistory.filter(m => m.role === 'assistant').pop();
         finalResponse = lastAssistantMessage?.content || 'Agent reached maximum iterations.';
     }
+    // Strip any unexecuted <tool_call> XML from final response so raw tags don't leak to output
+    if (finalResponse) {
+        finalResponse = finalResponse.replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '').trim();
+    }
     // Emit onAgentComplete checkpoint
     await emitChatAgentCheckpoint('onAgentComplete', {
         finalResponse,
@@ -4750,17 +5212,22 @@ function parseToolCall(response, format, allowedTools) {
         toolParameters: null,
     };
     const responseText = typeof response === 'string' ? response : JSON.stringify(response);
-    // Try XML format
+    // Try XML format — match first <tool_call> block, <params> is optional
     if (format === 'auto' || format === 'xml') {
-        const xmlMatch = responseText.match(/<tool_call>\s*<name>([^<]+)<\/name>\s*<params>([\s\S]*?)<\/params>\s*<\/tool_call>/i);
+        const xmlMatch = responseText.match(/<tool_call>\s*<name>([^<]+)<\/name>(?:\s*<params>([\s\S]*?)<\/params>)?\s*<\/tool_call>/i);
         if (xmlMatch) {
             result.hasToolCall = true;
             result.toolName = xmlMatch[1].trim();
-            try {
-                result.toolParameters = JSON.parse(xmlMatch[2].trim());
+            if (xmlMatch[2]) {
+                try {
+                    result.toolParameters = JSON.parse(xmlMatch[2].trim());
+                }
+                catch {
+                    result.toolParameters = { raw: xmlMatch[2].trim() };
+                }
             }
-            catch {
-                result.toolParameters = { raw: xmlMatch[2].trim() };
+            else {
+                result.toolParameters = {};
             }
             return result;
         }