Function determineNodesToIgnore

packages/server/src/utils/buildAgentflow.ts:799–842

* Determines which nodes should be ignored based on condition results * @param currentNode - The node being processed * @param result - The execution result from the node * @param edges - All edges in the workflow * @param nodeId - Current node ID * @returns Array of node IDs that should be ign

(
    currentNode: IReactFlowNode,
    result: any,
    edges: IReactFlowEdge[],
    nodeId: string
)

 * @returns Array of node IDs that should be ignored
 */
async function determineNodesToIgnore(
    currentNode: IReactFlowNode,
    result: any,
    edges: IReactFlowEdge[],
    nodeId: string
): Promise<string[]> {
    const ignoreNodeIds: string[] = []

    // Check if this is a decision node
    const isDecisionNode =
        currentNode.data.name === 'conditionAgentflow' ||
        currentNode.data.name === 'conditionAgentAgentflow' ||
        currentNode.data.name === 'humanInputAgentflow'

    if (isDecisionNode && result.output?.conditions) {
        const outputConditions: ICondition[] = result.output.conditions

        // safety net: if no conditions were fulfilled, don't ignore ALL children
        // treat the last condition as an else/default fallback
        const anyFulfilled = outputConditions.some((c) => c.isFulfilled === true)
        if (!anyFulfilled && outputConditions.length > 0) {
            // mark the last condition as fulfilled so at least one branch executes
            outputConditions[outputConditions.length - 1].isFulfilled = true
        }

        // Find indexes of unfulfilled conditions
        const unfulfilledIndexes = outputConditions
            .map((condition, index) =>
                condition.isFulfilled === false || !Object.prototype.hasOwnProperty.call(condition, 'isFulfilled') ? index : -1
            )
            .filter((index) => index !== -1)

        // Find nodes to ignore based on unfulfilled conditions
        for (const index of unfulfilledIndexes) {
            const ignoreEdge = edges.find((edge) => edge.source === nodeId && edge.sourceHandle === `${nodeId}-output-${index}`)

            if (ignoreEdge) {
                ignoreNodeIds.push(ignoreEdge.target)
            }
        }
    }

    return ignoreNodeIds
}

/**
 * Process node outputs and handle branching logic