feat: iteration support single run

web/app/components/workflow/nodes/_base/components/before-run-form/form.tsx

@@ -65,6 +65,8 @@ const Form: FC<Props> = ({
   const handleAddContext = useCallback(() => {
     const newValues = produce(values, (draft: any) => {
       const key = inputs[0].variable
+      if (!draft[key])
+        draft[key] = []
       draft[key].push(isContext ? RETRIEVAL_OUTPUT_STRUCT : '')
     })
     onChange(newValues)

web/app/components/workflow/nodes/_base/components/workflow-panel/last-run/use-last-run.ts

@@ -9,6 +9,7 @@ import useKnowledgeRetrievalSingleRunFormParams from '../../../../knowledge-retr
 import useCodeSingleRunFormParams from '../../../../code/use-single-run-form-params'
 import useTemplateTransformSingleRunFormParams from '../../../../template-transform/use-single-run-form-params'
 import useQuestionClassifierSingleRunFormParams from '../../../../question-classifier/use-single-run-form-params'
+import useIterationSingleRunFormParams from '../../../../iteration/use-single-run-form-params'
 import { BlockEnum } from '@/app/components/workflow/types'
 import {
   useNodesSyncDraft,
@@ -20,22 +21,22 @@ const singleRunFormParamsHooks: Record<BlockEnum, any> = {
   [BlockEnum.Code]: useCodeSingleRunFormParams,
   [BlockEnum.TemplateTransform]: useTemplateTransformSingleRunFormParams,
   [BlockEnum.QuestionClassifier]: useQuestionClassifierSingleRunFormParams,
+  [BlockEnum.HttpRequest]: undefined,
+  [BlockEnum.Tool]: undefined,
+  [BlockEnum.ParameterExtractor]: undefined,
+  [BlockEnum.Iteration]: useIterationSingleRunFormParams,
+  [BlockEnum.Agent]: undefined,
+  [BlockEnum.DocExtractor]: undefined,
+  [BlockEnum.Loop]: undefined,
   [BlockEnum.Start]: undefined,
   [BlockEnum.End]: undefined,
   [BlockEnum.Answer]: undefined,
   [BlockEnum.IfElse]: undefined,
-  [BlockEnum.HttpRequest]: undefined,
   [BlockEnum.VariableAssigner]: undefined,
   [BlockEnum.VariableAggregator]: undefined,
-  [BlockEnum.Tool]: undefined,
-  [BlockEnum.ParameterExtractor]: undefined,
-  [BlockEnum.Iteration]: undefined,
-  [BlockEnum.DocExtractor]: undefined,
   [BlockEnum.ListFilter]: undefined,
   [BlockEnum.IterationStart]: undefined,
   [BlockEnum.Assigner]: undefined,
-  [BlockEnum.Agent]: undefined,
-  [BlockEnum.Loop]: undefined,
   [BlockEnum.LoopStart]: undefined,
   [BlockEnum.LoopEnd]: undefined,
 }

web/app/components/workflow/nodes/iteration/panel.tsx

@@ -3,20 +3,15 @@ import React from 'react'
 import { useTranslation } from 'react-i18next'
 import VarReferencePicker from '../_base/components/variable/var-reference-picker'
 import Split from '../_base/components/split'
-import ResultPanel from '../../run/result-panel'
 import { MAX_ITERATION_PARALLEL_NUM, MIN_ITERATION_PARALLEL_NUM } from '../../constants'
 import type { IterationNodeType } from './types'
 import useConfig from './use-config'
-import { ErrorHandleMode, InputVarType, type NodePanelProps } from '@/app/components/workflow/types'
+import { ErrorHandleMode, type NodePanelProps } from '@/app/components/workflow/types'
 import Field from '@/app/components/workflow/nodes/_base/components/field'
-import BeforeRunForm from '@/app/components/workflow/nodes/_base/components/before-run-form'
 import Switch from '@/app/components/base/switch'
 import Select from '@/app/components/base/select'
 import Slider from '@/app/components/base/slider'
 import Input from '@/app/components/base/input'
-import formatTracing from '@/app/components/workflow/run/utils/format-log'
-
-import { useLogs } from '@/app/components/workflow/run/hooks'
 
 const i18nPrefix = 'workflow.nodes.iteration'
 
@@ -47,27 +42,11 @@ const Panel: FC<NodePanelProps<IterationNodeType>> = ({
     childrenNodeVars,
     iterationChildrenNodes,
     handleOutputVarChange,
-    isShowSingleRun,
-    hideSingleRun,
-    runningStatus,
-    handleRun,
-    handleStop,
-    runResult,
-    inputVarValues,
-    setInputVarValues,
-    usedOutVars,
-    iterator,
-    setIterator,
-    iteratorInputKey,
-    iterationRunResult,
     changeParallel,
     changeErrorResponseMode,
     changeParallelNums,
   } = useConfig(id, data)
 
-  const nodeInfo = formatTracing(iterationRunResult, t)[0]
-  const logsParams = useLogs()
-
   return (
     <div className='pb-2 pt-2'>
       <div className='space-y-4 px-4 pb-4'>
@@ -135,38 +114,6 @@ const Panel: FC<NodePanelProps<IterationNodeType>> = ({
           <Select items={responseMethod} defaultValue={inputs.error_handle_mode} onSelect={changeErrorResponseMode} allowSearch={false} />
         </Field>
       </div>
-
-      {isShowSingleRun && (
-        <BeforeRunForm
-          nodeName={inputs.title}
-          onHide={hideSingleRun}
-          forms={[
-            {
-              inputs: [...usedOutVars],
-              values: inputVarValues,
-              onChange: setInputVarValues,
-            },
-            {
-              label: t(`${i18nPrefix}.input`)!,
-              inputs: [{
-                label: '',
-                variable: iteratorInputKey,
-                type: InputVarType.iterator,
-                required: false,
-              }],
-              values: { [iteratorInputKey]: iterator },
-              onChange: keyValue => setIterator(keyValue[iteratorInputKey]),
-            },
-          ]}
-          runningStatus={runningStatus}
-          onRun={handleRun}
-          onStop={handleStop}
-          {...logsParams}
-          result={
-            <ResultPanel {...runResult} showSteps={false} nodeInfo={nodeInfo} {...logsParams} />
-          }
-        />
-      )}
     </div>
   )
 }

web/app/components/workflow/nodes/iteration/use-config.ts

@@ -1,30 +1,25 @@
 import { useCallback } from 'react'
 import produce from 'immer'
-import { useBoolean } from 'ahooks'
 import {
   useIsChatMode,
-  useIsNodeInIteration,
   useNodesReadOnly,
   useWorkflow,
 } from '../../hooks'
 import { VarType } from '../../types'
 import type { ErrorHandleMode, ValueSelector, Var } from '../../types'
 import useNodeCrud from '../_base/hooks/use-node-crud'
-import { getNodeInfoById, getNodeUsedVarPassToServerKey, getNodeUsedVars, isSystemVar, toNodeOutputVars } from '../_base/components/variable/utils'
-import useOneStepRun from '../_base/hooks/use-one-step-run'
 import type { IterationNodeType } from './types'
+import { toNodeOutputVars } from '../_base/components/variable/utils'
 import type { VarType as VarKindType } from '@/app/components/workflow/nodes/tool/types'
 import type { Item } from '@/app/components/base/select'
 import useInspectVarsCrud from '../../hooks/use-inspect-vars-crud'
 import { isEqual } from 'lodash-es'
 
-const DELIMITER = '@@@@@'
 const useConfig = (id: string, payload: IterationNodeType) => {
   const {
     deleteNodeInspectorVars,
   } = useInspectVarsCrud()
   const { nodesReadOnly: readOnly } = useNodesReadOnly()
-  const { isNodeInIteration } = useIsNodeInIteration(id)
   const isChatMode = useIsChatMode()
 
   const { inputs, setInputs } = useNodeCrud<IterationNodeType>(id, payload)
@@ -41,10 +36,8 @@ const useConfig = (id: string, payload: IterationNodeType) => {
   }, [inputs, setInputs])
 
   // output
-  const { getIterationNodeChildren, getBeforeNodesInSameBranch } = useWorkflow()
+  const { getIterationNodeChildren } = useWorkflow()
-  const beforeNodes = getBeforeNodesInSameBranch(id)
   const iterationChildrenNodes = getIterationNodeChildren(id)
-  const canChooseVarNodes = [...beforeNodes, ...iterationChildrenNodes]
   const childrenNodeVars = toNodeOutputVars(iterationChildrenNodes, isChatMode)
 
   const handleOutputVarChange = useCallback((output: ValueSelector | string, _varKindType: VarKindType, varInfo?: Var) => {
@@ -72,134 +65,6 @@ const useConfig = (id: string, payload: IterationNodeType) => {
     deleteNodeInspectorVars(id)
   }, [deleteNodeInspectorVars, id, inputs, setInputs])
 
-  // single run
-  const iteratorInputKey = `${id}.input_selector`
-  const {
-    isShowSingleRun,
-    showSingleRun,
-    hideSingleRun,
-    toVarInputs,
-    runningStatus,
-    handleRun: doHandleRun,
-    handleStop,
-    runInputData,
-    setRunInputData,
-    runResult,
-    iterationRunResult,
-  } = useOneStepRun<IterationNodeType>({
-    id,
-    data: inputs,
-    iteratorInputKey,
-    defaultRunInputData: {
-      [iteratorInputKey]: [''],
-    },
-  })
-
-  const [isShowIterationDetail, {
-    setTrue: doShowIterationDetail,
-    setFalse: doHideIterationDetail,
-  }] = useBoolean(false)
-
-  const hideIterationDetail = useCallback(() => {
-    hideSingleRun()
-    doHideIterationDetail()
-  }, [doHideIterationDetail, hideSingleRun])
-
-  const showIterationDetail = useCallback(() => {
-    doShowIterationDetail()
-  }, [doShowIterationDetail])
-
-  const backToSingleRun = useCallback(() => {
-    hideIterationDetail()
-    showSingleRun()
-  }, [hideIterationDetail, showSingleRun])
-
-  const { usedOutVars, allVarObject } = (() => {
-    const vars: ValueSelector[] = []
-    const varObjs: Record<string, boolean> = {}
-    const allVarObject: Record<string, {
-      inSingleRunPassedKey: string
-    }> = {}
-    iterationChildrenNodes.forEach((node) => {
-      const nodeVars = getNodeUsedVars(node).filter(item => item && item.length > 0)
-      nodeVars.forEach((varSelector) => {
-        if (varSelector[0] === id) { // skip iteration node itself variable: item, index
-          return
-        }
-        const isInIteration = isNodeInIteration(varSelector[0])
-        if (isInIteration) // not pass iteration inner variable
-          return
-
-        const varSectorStr = varSelector.join('.')
-        if (!varObjs[varSectorStr]) {
-          varObjs[varSectorStr] = true
-          vars.push(varSelector)
-        }
-        let passToServerKeys = getNodeUsedVarPassToServerKey(node, varSelector)
-        if (typeof passToServerKeys === 'string')
-          passToServerKeys = [passToServerKeys]
-
-        passToServerKeys.forEach((key: string, index: number) => {
-          allVarObject[[varSectorStr, node.id, index].join(DELIMITER)] = {
-            inSingleRunPassedKey: key,
-          }
-        })
-      })
-    })
-    const res = toVarInputs(vars.map((item) => {
-      const varInfo = getNodeInfoById(canChooseVarNodes, item[0])
-      return {
-        label: {
-          nodeType: varInfo?.data.type,
-          nodeName: varInfo?.data.title || canChooseVarNodes[0]?.data.title, // default start node title
-          variable: isSystemVar(item) ? item.join('.') : item[item.length - 1],
-        },
-        variable: `${item.join('.')}`,
-        value_selector: item,
-      }
-    }))
-    return {
-      usedOutVars: res,
-      allVarObject,
-    }
-  })()
-
-  const handleRun = useCallback((data: Record<string, any>) => {
-    const formattedData: Record<string, any> = {}
-    Object.keys(allVarObject).forEach((key) => {
-      const [varSectorStr, nodeId] = key.split(DELIMITER)
-      formattedData[`${nodeId}.${allVarObject[key].inSingleRunPassedKey}`] = data[varSectorStr]
-    })
-    formattedData[iteratorInputKey] = data[iteratorInputKey]
-    doHandleRun(formattedData)
-  }, [allVarObject, doHandleRun, iteratorInputKey])
-
-  const inputVarValues = (() => {
-    const vars: Record<string, any> = {}
-    Object.keys(runInputData)
-      .filter(key => ![iteratorInputKey].includes(key))
-      .forEach((key) => {
-        vars[key] = runInputData[key]
-      })
-    return vars
-  })()
-
-  const setInputVarValues = useCallback((newPayload: Record<string, any>) => {
-    const newVars = {
-      ...newPayload,
-      [iteratorInputKey]: runInputData[iteratorInputKey],
-    }
-    setRunInputData(newVars)
-  }, [iteratorInputKey, runInputData, setRunInputData])
-
-  const iterator = runInputData[iteratorInputKey]
-  const setIterator = useCallback((newIterator: string[]) => {
-    setRunInputData({
-      ...runInputData,
-      [iteratorInputKey]: newIterator,
-    })
-  }, [iteratorInputKey, runInputData, setRunInputData])
-
   const changeParallel = useCallback((value: boolean) => {
     const newInputs = produce(inputs, (draft) => {
       draft.is_parallel = value
@@ -227,24 +92,6 @@ const useConfig = (id: string, payload: IterationNodeType) => {
     childrenNodeVars,
     iterationChildrenNodes,
     handleOutputVarChange,
-    isShowSingleRun,
-    showSingleRun,
-    hideSingleRun,
-    isShowIterationDetail,
-    showIterationDetail,
-    hideIterationDetail,
-    backToSingleRun,
-    runningStatus,
-    handleRun,
-    handleStop,
-    runResult,
-    inputVarValues,
-    setInputVarValues,
-    usedOutVars,
-    iterator,
-    setIterator,
-    iteratorInputKey,
-    iterationRunResult,
     changeParallel,
     changeErrorResponseMode,
     changeParallelNums,

web/app/components/workflow/nodes/iteration/use-single-run-form-params.ts

@@ -0,0 +1,132 @@
+import type { MutableRefObject } from 'react'
+import type { InputVar, ValueSelector, Variable } from '@/app/components/workflow/types'
+import { useCallback, useMemo } from 'react'
+import type { IterationNodeType } from './types'
+import { useTranslation } from 'react-i18next'
+import { useIsNodeInIteration, useWorkflow } from '../../hooks'
+import { getNodeInfoById, getNodeUsedVarPassToServerKey, getNodeUsedVars, isSystemVar } from '../_base/components/variable/utils'
+import { InputVarType } from '@/app/components/workflow/types'
+
+const i18nPrefix = 'workflow.nodes.iteration'
+const DELIMITER = '@@@@@'
+
+type Params = {
+  id: string,
+  payload: IterationNodeType,
+  runInputData: Record<string, any>
+  runInputDataRef: MutableRefObject<Record<string, any>>
+  getInputVars: (textList: string[]) => InputVar[]
+  setRunInputData: (data: Record<string, any>) => void
+  toVarInputs: (variables: Variable[]) => InputVar[]
+}
+const useSingleRunFormParams = ({
+  id,
+  runInputData,
+  toVarInputs,
+  setRunInputData,
+}: Params) => {
+  const { t } = useTranslation()
+  const { isNodeInIteration } = useIsNodeInIteration(id)
+
+  const { getIterationNodeChildren, getBeforeNodesInSameBranch } = useWorkflow()
+  const iterationChildrenNodes = getIterationNodeChildren(id)
+  const beforeNodes = getBeforeNodesInSameBranch(id)
+  const canChooseVarNodes = [...beforeNodes, ...iterationChildrenNodes]
+
+  const iteratorInputKey = `${id}.input_selector`
+  const iterator = runInputData[iteratorInputKey]
+  const setIterator = useCallback((newIterator: string[]) => {
+    setRunInputData({
+      ...runInputData,
+      [iteratorInputKey]: newIterator,
+    })
+  }, [iteratorInputKey, runInputData, setRunInputData])
+
+  const { usedOutVars } = (() => {
+    const vars: ValueSelector[] = []
+    const varObjs: Record<string, boolean> = {}
+    const allVarObject: Record<string, {
+      inSingleRunPassedKey: string
+    }> = {}
+    iterationChildrenNodes.forEach((node) => {
+      const nodeVars = getNodeUsedVars(node).filter(item => item && item.length > 0)
+      nodeVars.forEach((varSelector) => {
+        if (varSelector[0] === id) { // skip iteration node itself variable: item, index
+          return
+        }
+        const isInIteration = isNodeInIteration(varSelector[0])
+        if (isInIteration) // not pass iteration inner variable
+          return
+
+        const varSectorStr = varSelector.join('.')
+        if (!varObjs[varSectorStr]) {
+          varObjs[varSectorStr] = true
+          vars.push(varSelector)
+        }
+        let passToServerKeys = getNodeUsedVarPassToServerKey(node, varSelector)
+        if (typeof passToServerKeys === 'string')
+          passToServerKeys = [passToServerKeys]
+
+        passToServerKeys.forEach((key: string, index: number) => {
+          allVarObject[[varSectorStr, node.id, index].join(DELIMITER)] = {
+            inSingleRunPassedKey: key,
+          }
+        })
+      })
+    })
+    const res = toVarInputs(vars.map((item) => {
+      const varInfo = getNodeInfoById(canChooseVarNodes, item[0])
+      return {
+        label: {
+          nodeType: varInfo?.data.type,
+          nodeName: varInfo?.data.title || canChooseVarNodes[0]?.data.title, // default start node title
+          variable: isSystemVar(item) ? item.join('.') : item[item.length - 1],
+        },
+        variable: `${item.join('.')}`,
+        value_selector: item,
+      }
+    }))
+    return {
+      usedOutVars: res,
+    }
+  })()
+
+  const setInputVarValues = useCallback((newPayload: Record<string, any>) => {
+    setRunInputData(newPayload)
+  }, [setRunInputData])
+  const inputVarValues = (() => {
+    const vars: Record<string, any> = {}
+    Object.keys(runInputData)
+      .forEach((key) => {
+        vars[key] = runInputData[key]
+      })
+    return vars
+  })()
+
+  const forms = useMemo(() => {
+    return [
+      {
+        inputs: [...usedOutVars],
+        values: inputVarValues,
+        onChange: setInputVarValues,
+      },
+      {
+        label: t(`${i18nPrefix}.input`)!,
+        inputs: [{
+          label: '',
+          variable: iteratorInputKey,
+          type: InputVarType.iterator,
+          required: false,
+        }],
+        values: { [iteratorInputKey]: iterator },
+        onChange: (keyValue: Record<string, any>) => setIterator(keyValue[iteratorInputKey]),
+      },
+    ]
+  }, [inputVarValues, iterator, iteratorInputKey, setInputVarValues, setIterator, t, usedOutVars])
+
+  return {
+    forms,
+  }
+}
+
+export default useSingleRunFormParams