Feat: Add child nodes and their connecting lines by clicking #3221 (#8314)

### What problem does this PR solve?
Feat: Add child nodes and their connecting lines by clicking #3221

### Type of change


- [x] New Feature (non-breaking change which adds functionality)

web/src/pages/agent/canvas/node/agent-node.tsx

 import { IAgentNode } from '@/interfaces/database/flow';
 import { Handle, NodeProps, Position } from '@xyflow/react';
 import { memo, useMemo } from 'react';
-import { Operator } from '../../constant';
+import { NodeHandleId, Operator } from '../../constant';
 import useGraphStore from '../../store';
 import { CommonHandle } from './handle';
 import { LeftHandleStyle, RightHandleStyle } from './handle-icon';
         {isNotParentAgent && (
           <>
             <CommonHandle
-              id="c"
-              type="source"
+              type="target"
               position={Position.Left}
               isConnectable={isConnectable}
               style={LeftHandleStyle}
               nodeId={id}
+              id={NodeHandleId.End}
             ></CommonHandle>
             <CommonHandle
               type="source"
               position={Position.Right}
               isConnectable={isConnectable}
               className={styles.handle}
-              id="b"
               style={RightHandleStyle}
               nodeId={id}
+              id={NodeHandleId.Start}
+              isConnectableEnd={false}
             ></CommonHandle>
           </>
         )}

web/src/pages/agent/canvas/node/begin-node.tsx

 import {
   BeginQueryType,
   BeginQueryTypeIconMap,
+  NodeHandleId,
   Operator,
 } from '../../constant';
 import { BeginQuery } from '../../interface';
         type="source"
         position={Position.Right}
         isConnectable
-        className={styles.handle}
         style={RightHandleStyle}
         nodeId={id}
+        id={NodeHandleId.Start}
       ></CommonHandle>
 
       <section className="flex items-center justify-center gap-2">

web/src/pages/agent/canvas/node/categorize-node.tsx

 import { NodeProps, Position } from '@xyflow/react';
 import { get } from 'lodash';
 import { memo } from 'react';
+import { NodeHandleId } from '../../constant';
 import { CommonHandle } from './handle';
 import { RightHandleStyle } from './handle-icon';
 import NodeHeader from './node-header';
           type="target"
           position={Position.Left}
           isConnectable
-          id={'a'}
+          id={NodeHandleId.End}
           nodeId={id}
         ></CommonHandle>
 
                   isConnectable
                   style={{ ...RightHandleStyle, top: position.top }}
                   nodeId={id}
+                  isConnectableEnd={false}
                 ></CommonHandle>
               </div>
             );

web/src/pages/agent/canvas/node/dropdown/next-step-dropdown.tsx

             key={x}
             className="hover:bg-background-card py-1 px-3 cursor-pointer rounded-sm flex gap-2 items-center justify-start"
             onClick={addCanvasNode(x, {
-              id: nodeId,
-              sourceHandle: id,
+              nodeId,
+              id,
               position,
             })}
           >

web/src/pages/agent/canvas/node/index.tsx

 import { IRagNode } from '@/interfaces/database/flow';
 import { NodeProps, Position } from '@xyflow/react';
 import { memo } from 'react';
+import { NodeHandleId } from '../../constant';
 import { CommonHandle } from './handle';
 import { LeftHandleStyle, RightHandleStyle } from './handle-icon';
 import NodeHeader from './node-header';
     <ToolBar selected={selected} id={id} label={data.label}>
       <NodeWrapper>
         <CommonHandle
-          id="c"
-          type="source"
+          id={NodeHandleId.End}
+          type="target"
           position={Position.Left}
           isConnectable={isConnectable}
           style={LeftHandleStyle}
           type="source"
           position={Position.Right}
           isConnectable={isConnectable}
-          id="b"
+          id={NodeHandleId.Start}
           style={RightHandleStyle}
           nodeId={id}
+          isConnectableEnd={false}
         ></CommonHandle>
         <NodeHeader id={id} name={data.name} label={data.label}></NodeHeader>
       </NodeWrapper>

web/src/pages/agent/canvas/node/message-node.tsx

 import classNames from 'classnames';
 import { get } from 'lodash';
 import { memo } from 'react';
+import { NodeHandleId } from '../../constant';
 import { CommonHandle } from './handle';
 import { LeftHandleStyle, RightHandleStyle } from './handle-icon';
 import styles from './index.less';
     <ToolBar selected={selected} id={id} label={data.label}>
       <NodeWrapper>
         <CommonHandle
-          id="c"
-          type="source"
+          type="target"
           position={Position.Left}
           isConnectable={isConnectable}
           style={LeftHandleStyle}
           nodeId={id}
+          id={NodeHandleId.End}
         ></CommonHandle>
         <CommonHandle
           type="source"
           position={Position.Right}
           isConnectable={isConnectable}
           style={RightHandleStyle}
-          id="b"
+          id={NodeHandleId.Start}
           nodeId={id}
+          isConnectableEnd={false}
         ></CommonHandle>
         <NodeHeader
           id={id}

web/src/pages/agent/canvas/node/retrieval-node.tsx

 import classNames from 'classnames';
 import { get } from 'lodash';
 import { memo, useMemo } from 'react';
+import { NodeHandleId } from '../../constant';
 import { CommonHandle } from './handle';
 import { LeftHandleStyle, RightHandleStyle } from './handle-icon';
 import styles from './index.less';
     <ToolBar selected={selected} id={id} label={data.label}>
       <NodeWrapper>
         <CommonHandle
-          id="c"
-          type="source"
+          id={NodeHandleId.End}
+          type="target"
           position={Position.Left}
           isConnectable={isConnectable}
           className={styles.handle}
           nodeId={id}
         ></CommonHandle>
         <CommonHandle
+          id={NodeHandleId.Start}
           type="source"
           position={Position.Right}
           isConnectable={isConnectable}
           className={styles.handle}
           style={RightHandleStyle}
-          id="b"
           nodeId={id}
+          isConnectableEnd={false}
         ></CommonHandle>
         <NodeHeader
           id={id}

web/src/pages/agent/canvas/node/switch-node.tsx

 import { ISwitchCondition, ISwitchNode } from '@/interfaces/database/flow';
 import { NodeProps, Position } from '@xyflow/react';
 import { memo, useCallback } from 'react';
-import { SwitchOperatorOptions } from '../../constant';
+import { NodeHandleId, SwitchOperatorOptions } from '../../constant';
 import { useGetComponentLabelByValue } from '../../hooks/use-get-begin-query';
 import { CommonHandle } from './handle';
 import { RightHandleStyle } from './handle-icon';
           type="target"
           position={Position.Left}
           isConnectable
-          id={'a'}
           nodeId={id}
+          id={NodeHandleId.End}
         ></CommonHandle>
         <NodeHeader id={id} name={data.name} label={data.label}></NodeHeader>
         <section className="gap-2.5 flex flex-col">
                   isConnectable
                   style={{ ...RightHandleStyle, top: position.top }}
                   nodeId={id}
+                  isConnectableEnd={false}
                 ></CommonHandle>
               </div>
             );

web/src/pages/agent/constant.tsx

   Operator.Switch,
   Operator.Iteration,
 ];
+
+export enum NodeHandleId {
+  Start = 'start',
+  End = 'end',
+}

web/src/pages/agent/form/agent-form/index.tsx

         </FormContainer>
         <BlockButton
           onClick={addCanvasNode(Operator.Agent, {
-            id: node?.id,
+            nodeId: node?.id,
             position: Position.Bottom,
           })}
         >

web/src/pages/agent/hooks/use-add-node.ts

 import { useFetchModelId } from '@/hooks/logic-hooks';
-import { Node, Position, ReactFlowInstance } from '@xyflow/react';
+import { Connection, Node, Position, ReactFlowInstance } from '@xyflow/react';
 import humanId from 'human-id';
 import { lowerFirst } from 'lodash';
 import { useCallback, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import {
+  NodeHandleId,
   NodeMap,
   Operator,
   initialAgentValues,
       const maxY = Math.max(...yAxises);
 
       const position = {
-        y: yAxises.length > 0 ? maxY + 262 : (parentNode?.position.y || 0) + 82,
-        x: (parentNode?.position.x || 0) + 140,
+        y: yAxises.length > 0 ? maxY + 150 : parentNode?.position.y || 0,
+        x: (parentNode?.position.x || 0) + 300,
       };
 
       return position;
   return { calculateNewlyBackChildPosition };
 }
 
+function useAddChildEdge() {
+  const addEdge = useGraphStore((state) => state.addEdge);
+
+  const addChildEdge = useCallback(
+    (position: Position = Position.Right, edge: Partial<Connection>) => {
+      if (
+        position === Position.Right &&
+        edge.source &&
+        edge.target &&
+        edge.sourceHandle
+      ) {
+        addEdge({
+          source: edge.source,
+          target: edge.target,
+          sourceHandle: edge.sourceHandle,
+          targetHandle: NodeHandleId.End,
+        });
+      }
+    },
+    [addEdge],
+  );
+
+  return { addChildEdge };
+}
+
 export function useAddNode(reactFlowInstance?: ReactFlowInstance<any, any>) {
   const addNode = useGraphStore((state) => state.addNode);
   const getNode = useGraphStore((state) => state.getNode);
   const getNodeName = useGetNodeName();
   const initializeOperatorParams = useInitializeOperatorParams();
   const { calculateNewlyBackChildPosition } = useCalculateNewlyChildPosition();
+  const { addChildEdge } = useAddChildEdge();
   //   const [reactFlowInstance, setReactFlowInstance] =
   //     useState<ReactFlowInstance<any, any>>();
 
   const addCanvasNode = useCallback(
     (
       type: string,
-      params: { id?: string; position?: Position; sourceHandle?: string } = {
+      params: { nodeId?: string; position: Position; id?: string } = {
         position: Position.Right,
       },
     ) =>
       (event: React.MouseEvent<HTMLElement>) => {
-        const id = params.id;
+        const nodeId = params.nodeId;
 
         // reactFlowInstance.project was renamed to reactFlowInstance.screenToFlowPosition
         // and you don't need to subtract the reactFlowBounds.left/top anymore
         });
 
         if (params.position === Position.Right) {
-          position = calculateNewlyBackChildPosition(id, params.sourceHandle);
+          position = calculateNewlyBackChildPosition(nodeId, params.id);
         }
 
         const newNode: Node<any> = {
           };
           addNode(newNode);
           addNode(iterationStartNode);
-        } else if (type === Operator.Agent) {
-          const agentNode = getNode(id);
+        } else if (
+          type === Operator.Agent &&
+          params.position === Position.Bottom
+        ) {
+          const agentNode = getNode(nodeId);
           if (agentNode) {
             // Calculate the coordinates of child nodes to prevent newly added child nodes from covering other child nodes
             const allChildAgentNodeIds = edges
-              .filter((x) => x.source === id && x.sourceHandle === 'e')
+              .filter((x) => x.source === nodeId && x.sourceHandle === 'e')
               .map((x) => x.target);
 
             const xAxises = nodes
             };
           }
           addNode(newNode);
-          if (id) {
+          if (nodeId) {
             addEdge({
-              source: id,
+              source: nodeId,
               target: newNode.id,
               sourceHandle: 'e',
               targetHandle: 'f',
             newNode.extent = 'parent';
           }
           addNode(newNode);
+          addChildEdge(params.position, {
+            source: params.nodeId,
+            target: newNode.id,
+            sourceHandle: params.id,
+          });
         }
       },
     [
+      addChildEdge,
       addEdge,
       addNode,
+      calculateNewlyBackChildPosition,
       edges,
       getNode,
       getNodeName,