Feat: Insert the node data of the bottom subagent into the tool array of the head agent #3221 (#8471)

### What problem does this PR solve?

Feat: Insert the node data of the bottom subagent into the tool array of
the head agent #3221

### Type of change


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

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

 import { useForm } from 'react-hook-form';
 import { useTranslation } from 'react-i18next';
 import { z } from 'zod';
-import { NodeHandleId, Operator, initialAgentValues } from '../../constant';
+import { Operator, initialAgentValues } from '../../constant';
 import { AgentInstanceContext } from '../../context';
 import { INextOperatorForm } from '../../interface';
 import useGraphStore from '../../store';
+import { isBottomSubAgent } from '../../utils';
 import { Output } from '../components/output';
 import { PromptEditor } from '../components/prompt-editor';
 import { AgentTools } from './agent-tools';
   const defaultValues = useValues(node);
 
   const isSubAgent = useMemo(() => {
-    const edge = edges.find(
-      (x) => x.target === node?.id && x.targetHandle === NodeHandleId.AgentTop,
-    );
-    return !!edge;
+    return isBottomSubAgent(edges, node?.id);
   }, [edges, node?.id]);
 
   const outputList = useMemo(() => {

web/src/pages/agent/utils.ts

 import {
   CategorizeAnchorPointPositions,
   NoDebugOperatorsList,
+  NodeHandleId,
   NodeMap,
   Operator,
 } from './constant';
     .filter((y) => {
       const node = nodes.find((x) => x.id === nodeId);
       let isNotUpstreamTool = true;
+      let isNotUpstreamAgent = true;
       if (isBuildDownstream && node?.data.label === Operator.Agent) {
-        isNotUpstreamTool = !y.target.startsWith(Operator.Tool); // Exclude the tool operator downstream of the agent operator
+        // Exclude the tool operator downstream of the agent operator
+        isNotUpstreamTool = !y.target.startsWith(Operator.Tool);
+        // Exclude the agent operator downstream of the agent operator
+        isNotUpstreamAgent = !(
+          y.target.startsWith(Operator.Agent) &&
+          y.targetHandle === NodeHandleId.AgentTop
+        );
       }
       return (
         y[isBuildDownstream ? 'source' : 'target'] === nodeId &&
-        isNotUpstreamTool
+        isNotUpstreamTool &&
+        isNotUpstreamAgent
       );
     })
     .map((y) => y[isBuildDownstream ? 'target' : 'source']);
 //   return values;
 // });
 
+function buildAgentTools(edges: Edge[], nodes: Node[], nodeId: string) {
+  const node = nodes.find((x) => x.id === nodeId);
+  const params = { ...(node?.data.form ?? {}) };
+  if (node && node.data.label === Operator.Agent) {
+    const bottomSubAgentEdges = edges.filter(
+      (x) => x.source === nodeId && x.sourceHandle === NodeHandleId.AgentBottom,
+    );
+
+    (params as IAgentForm).tools = (params as IAgentForm).tools.concat(
+      bottomSubAgentEdges.map((x) => {
+        const formData = buildAgentTools(edges, nodes, x.target);
+
+        return { component_name: Operator.Agent, params: { ...formData } };
+      }),
+    );
+  }
+  return params;
+}
+
 const buildOperatorParams = (operatorName: string) =>
   pipe(
     removeUselessDataInTheOperator(operatorName),
 
 const ExcludeOperators = [Operator.Note, Operator.Tool];
 
+export function isBottomSubAgent(edges: Edge[], nodeId?: string) {
+  const edge = edges.find(
+    (x) => x.target === nodeId && x.targetHandle === NodeHandleId.AgentTop,
+  );
+  return !!edge;
+}
+
 // construct a dsl based on the node information of the graph
 export const buildDslComponentsByGraph = (
   nodes: RAGFlowNodeType[],
   const components: DSLComponents = {};
 
   nodes
-    ?.filter((x) => !ExcludeOperators.some((y) => y === x.data.label))
+    ?.filter(
+      (x) =>
+        !ExcludeOperators.some((y) => y === x.data.label) &&
+        !isBottomSubAgent(edges, x.id),
+    )
     .forEach((x) => {
       const id = x.id;
       const operatorName = x.data.label;
+
+      const params = buildAgentTools(edges, nodes, id);
       components[id] = {
         obj: {
           ...(oldDslComponents[id]?.obj ?? {}),
           component_name: operatorName,
-          params:
-            buildOperatorParams(operatorName)(
-              x.data.form as Record<string, unknown>,
-            ) ?? {},
+          params: buildOperatorParams(operatorName)(params) ?? {},
         },
         downstream: buildComponentDownstreamOrUpstream(edges, id, true, nodes),
         upstream: buildComponentDownstreamOrUpstream(edges, id, false, nodes),