feat: run flow (#1076)

### What problem does this PR solve?

feat: run flow #918 

### Type of change


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

web/src/hooks/flow-hooks.ts

 
   return { data, loading, deleteFlow: mutateAsync };
 };
+
+export const useRunFlow = () => {
+  const {
+    data,
+    isPending: loading,
+    mutateAsync,
+  } = useMutation({
+    mutationKey: ['runFlow'],
+    mutationFn: async (params: { id: string; dsl: DSL }) => {
+      const { data } = await flowService.runCanvas(params);
+      if (data.retcode === 0) {
+        message.success(i18n.t(`message.modified`));
+      }
+      return data?.data ?? {};
+    },
+  });
+
+  return { data, loading, runFlow: mutateAsync };
+};

web/src/pages/flow/constant.ts

-import { ModelVariableType } from '@/constants/knowledge';
-
 export enum Operator {
   Begin = 'Begin',
   Retrieval = 'Retrieval',
 };
 
 export const initialGenerateValues = {
-  parameters: ModelVariableType.Precise,
-  temperatureEnabled: false,
+  // parameters: ModelVariableType.Precise,
+  // temperatureEnabled: true,
   temperature: 0.1,
   top_p: 0.3,
   frequency_penalty: 0.7,
 The above is the content you need to summarize.`,
   cite: true,
 };
+
+export const initialFormValuesMap = {
+  [Operator.Begin]: initialBeginValues,
+  [Operator.Retrieval]: initialRetrievalValues,
+  [Operator.Generate]: initialGenerateValues,
+  [Operator.Answer]: {},
+};

web/src/pages/flow/header/index.tsx

 import { Button, Flex } from 'antd';
 
-import { useSaveGraph } from '../hooks';
+import { useRunGraph, useSaveGraph } from '../hooks';
 import styles from './index.less';
 
 const FlowHeader = () => {
   const { saveGraph } = useSaveGraph();
+  const { runGraph } = useRunGraph();
 
   return (
     <Flex
       gap={'large'}
       className={styles.flowHeader}
     >
-      <Button>
+      <Button onClick={runGraph}>
         <b>Debug</b>
       </Button>
       <Button type="primary" onClick={saveGraph}>

web/src/pages/flow/hooks.ts

 import {
   useFetchFlow,
   useFetchFlowTemplates,
+  useRunFlow,
   useSetFlow,
 } from '@/hooks/flow-hooks';
 import { useFetchLlmList } from '@/hooks/llmHooks';
           x: 0,
           y: 0,
         },
-        data: { label: `${type}` },
+        data: {
+          label: `${type}`,
+        },
         sourcePosition: Position.Right,
         targetPosition: Position.Left,
       };
   const { nodes, edges } = useStore((state) => state);
   const saveGraph = useCallback(() => {
     const dslComponents = buildDslComponentsByGraph(nodes, edges);
-    console.info('components:', dslComponents);
     setFlow({
       id,
       title: data.title,
 export const useFlowIsFetching = () => {
   return useIsFetching({ queryKey: ['flowDetail'] }) > 0;
 };
+
+export const useRunGraph = () => {
+  const { data } = useFetchFlow();
+  const { runFlow } = useRunFlow();
+  const { id } = useParams();
+  const { nodes, edges } = useStore((state) => state);
+  const runGraph = useCallback(() => {
+    const dslComponents = buildDslComponentsByGraph(nodes, edges);
+    runFlow({
+      id: id!!,
+      dsl: { ...data.dsl, components: dslComponents },
+    });
+  }, [nodes, edges, runFlow, id, data]);
+
+  return { runGraph };
+};

web/src/pages/flow/mock.tsx

     },
   },
   history: [],
-  path: ['begin'],
+  path: [],
   answer: [],
 };

web/src/pages/flow/utils.ts

 import { DSLComponents } from '@/interfaces/database/flow';
 import { removeUselessFieldsFromValues } from '@/utils/form';
 import dagre from 'dagre';
+import { curry, isEmpty } from 'lodash';
+import pipe from 'lodash/fp/pipe';
 import { Edge, MarkerType, Node, Position } from 'reactflow';
 import { v4 as uuidv4 } from 'uuid';
+import { Operator, initialFormValuesMap } from './constant';
 import { NodeData } from './interface';
 
 const buildEdges = (
     .map((y) => y[isBuildDownstream ? 'target' : 'source']);
 };
 
-const removeUselessDataInTheOperator = (
-  operatorName: string,
-  params: Record<string, unknown>,
-) => {
-  if (operatorName === 'Generate') {
-    return removeUselessFieldsFromValues(params, '');
+const removeUselessDataInTheOperator = curry(
+  (operatorName: string, params: Record<string, unknown>) => {
+    if (operatorName === Operator.Generate) {
+      return removeUselessFieldsFromValues(params, '');
+    }
+    return params;
+  },
+);
+// initialize data for operators without parameters
+const initializeOperatorParams = curry((operatorName: string, values: any) => {
+  if (isEmpty(values)) {
+    return initialFormValuesMap[operatorName as Operator];
   }
-  return params;
-};
+  return values;
+});
+
+const buildOperatorParams = (operatorName: string) =>
+  pipe(
+    removeUselessDataInTheOperator(operatorName),
+    initializeOperatorParams(operatorName), // Final processing, for guarantee
+  );
 
 // construct a dsl based on the node information of the graph
 export const buildDslComponentsByGraph = (
     components[id] = {
       obj: {
         component_name: operatorName,
+        // params:
+        //   removeUselessDataInTheOperator(
+        //     operatorName,
+        //     x.data.form as Record<string, unknown>,
+        //   ) ?? {},
         params:
-          removeUselessDataInTheOperator(
-            operatorName,
+          buildOperatorParams(operatorName)(
             x.data.form as Record<string, unknown>,
           ) ?? {},
       },

web/src/services/flow-service.ts

   listCanvas,
   resetCanvas,
   removeCanvas,
+  runCanvas,
   listTemplates,
 } = api;
 
     url: removeCanvas,
     method: 'post',
   },
+  runCanvas: {
+    url: runCanvas,
+    method: 'post',
+  },
   listTemplates: {
     url: listTemplates,
     method: 'get',

web/src/utils/api.ts

   removeCanvas: `${api_host}/canvas/rm`,
   setCanvas: `${api_host}/canvas/set`,
   resetCanvas: `${api_host}/canvas/reset`,
+  runCanvas: `${api_host}/canvas/run`,
 };

web/src/utils/form.ts

 
 // chat model setting and generate operator
 export const excludeUnEnabledVariables = (
-  values: any,
+  values: any = {},
   prefix = 'llm_setting.',
 ) => {
   const unEnabledFields: Array<keyof typeof variableEnabledFieldMap> =