feat: loop node

packages/global/core/workflow/constants.ts

@@ -24,6 +24,7 @@ export enum WorkflowIOValueTypeEnum {
   arrayNumber = 'arrayNumber',
   arrayBoolean = 'arrayBoolean',
   arrayObject = 'arrayObject',
+  arrayAny = 'arrayAny',
   any = 'any',
 
   chatHistory = 'chatHistory',
@@ -135,7 +136,17 @@ export enum NodeInputKeyEnum {
   fileUrlList = 'fileUrlList',
 
   // user select
-  userSelectOptions = 'userSelectOptions'
+  userSelectOptions = 'userSelectOptions',
+
+  // loop
+  loopInputArray = 'loopInputArray',
+  loopFlow = 'loopFlow',
+
+  // loop start
+  loopArrayElement = 'loopArrayElement',
+
+  // loop end
+  loopOutputArrayElement = 'loopOutputArrayElement'
 }
 
 export enum NodeOutputKeyEnum {
@@ -178,7 +189,13 @@ export enum NodeOutputKeyEnum {
   ifElseResult = 'ifElseResult',
 
   //user select
-  selectResult = 'selectResult'
+  selectResult = 'selectResult',
+
+  // loop
+  loopArray = 'loopArray',
+
+  // loop start
+  loopArrayElement = 'loopArrayElement'
 }
 
 export enum VariableInputEnum {

packages/global/core/workflow/node/constant.ts

@@ -125,7 +125,10 @@ export enum FlowNodeTypeEnum {
   textEditor = 'textEditor',
   customFeedback = 'customFeedback',
   readFiles = 'readFiles',
-  userSelect = 'userSelect'
+  userSelect = 'userSelect',
+  loop = 'loop',
+  loopStart = 'loopStart',
+  loopEnd = 'loopEnd'
 }
 
 // node IO value type
@@ -162,6 +165,10 @@ export const FlowValueTypeMap = {
     label: 'array<object>',
     value: WorkflowIOValueTypeEnum.arrayObject
   },
+  [WorkflowIOValueTypeEnum.arrayAny]: {
+    label: 'array',
+    value: WorkflowIOValueTypeEnum.arrayAny
+  },
   [WorkflowIOValueTypeEnum.any]: {
     label: 'any',
     value: WorkflowIOValueTypeEnum.any

packages/global/core/workflow/runtime/type.d.ts

@@ -172,6 +172,15 @@ export type DispatchNodeResponseType = {
 
   // update var
   updateVarResult?: any[];
+
+  // loop
+  loopResult?: any[];
+  loopInput?: any[];
+  loopDetail?: ChatHistoryItemResType[];
+  // loop start
+  loopInputValue?: any;
+  // loop end
+  loopOutputValue?: any;
 };
 
 export type DispatchNodeResultType<T = {}> = {

packages/global/core/workflow/template/constants.ts

@@ -29,6 +29,9 @@ import { TextEditorNode } from './system/textEditor';
 import { CustomFeedbackNode } from './system/customFeedback';
 import { ReadFilesNodes } from './system/readFiles';
 import { UserSelectNode } from './system/userSelect/index';
+import { LoopNode } from './system/loop/loop';
+import { LoopStartNode } from './system/loop/loopStart';
+import { LoopEndNode } from './system/loop/loopEnd';
 
 const systemNodes: FlowNodeTemplateType[] = [
   AiChatModule,
@@ -46,7 +49,8 @@ const systemNodes: FlowNodeTemplateType[] = [
   LafModule,
   IfElseNode,
   VariableUpdateNode,
-  CodeNode
+  CodeNode,
+  LoopNode
 ];
 /* app flow module templates */
 export const appSystemModuleTemplates: FlowNodeTemplateType[] = [
@@ -74,5 +78,7 @@ export const moduleTemplatesFlat: FlowNodeTemplateType[] = [
   EmptyNode,
   RunPluginModule,
   RunAppNode,
-  RunAppModule
+  RunAppModule,
+  LoopStartNode,
+  LoopEndNode
 ];

packages/global/core/workflow/template/system/loop/loop.ts

@@ -0,0 +1,57 @@
+import {
+  FlowNodeInputTypeEnum,
+  FlowNodeOutputTypeEnum,
+  FlowNodeTypeEnum
+} from '../../../node/constant';
+import { FlowNodeTemplateType } from '../../../type/node';
+import {
+  FlowNodeTemplateTypeEnum,
+  NodeInputKeyEnum,
+  NodeOutputKeyEnum,
+  WorkflowIOValueTypeEnum
+} from '../../../constants';
+import { getHandleConfig } from '../../utils';
+import { i18nT } from '../../../../../../web/i18n/utils';
+
+export const LoopNode: FlowNodeTemplateType = {
+  id: FlowNodeTypeEnum.loop,
+  templateType: FlowNodeTemplateTypeEnum.tools,
+  flowNodeType: FlowNodeTypeEnum.loop,
+  sourceHandle: getHandleConfig(true, true, true, true),
+  targetHandle: getHandleConfig(true, true, true, true),
+  avatar: 'core/workflow/template/loop',
+  name: i18nT('workflow:loop'),
+  intro: i18nT('workflow:intro_loop'),
+  showStatus: true,
+  version: '4811',
+  inputs: [
+    {
+      key: NodeInputKeyEnum.loopInputArray,
+      renderTypeList: [FlowNodeInputTypeEnum.reference],
+      valueType: WorkflowIOValueTypeEnum.arrayAny,
+      required: true,
+      label: i18nT('workflow:loop_input_array'),
+      value: []
+    },
+    {
+      key: NodeInputKeyEnum.loopFlow,
+      renderTypeList: [FlowNodeInputTypeEnum.hidden],
+      valueType: WorkflowIOValueTypeEnum.any,
+      label: '',
+      value: {
+        width: 0,
+        height: 0,
+        childNodes: []
+      }
+    }
+  ],
+  outputs: [
+    {
+      id: NodeOutputKeyEnum.loopArray,
+      key: NodeOutputKeyEnum.loopArray,
+      label: i18nT('workflow:loop_result'),
+      type: FlowNodeOutputTypeEnum.static,
+      valueType: WorkflowIOValueTypeEnum.arrayAny
+    }
+  ]
+};

packages/global/core/workflow/template/system/loop/loopEnd.ts

@@ -0,0 +1,35 @@
+import { i18nT } from '../../../../../../web/i18n/utils';
+import {
+  FlowNodeTemplateTypeEnum,
+  NodeInputKeyEnum,
+  WorkflowIOValueTypeEnum
+} from '../../../constants';
+import { FlowNodeInputTypeEnum, FlowNodeTypeEnum } from '../../../node/constant';
+import { FlowNodeTemplateType } from '../../../type/node';
+import { getHandleConfig } from '../../utils';
+
+export const LoopEndNode: FlowNodeTemplateType = {
+  id: FlowNodeTypeEnum.loopEnd,
+  templateType: FlowNodeTemplateTypeEnum.systemInput,
+  flowNodeType: FlowNodeTypeEnum.loopEnd,
+  sourceHandle: getHandleConfig(false, false, false, false),
+  targetHandle: getHandleConfig(false, false, false, true),
+  unique: true,
+  forbidDelete: true,
+  avatar: 'core/workflow/template/loopEnd',
+  name: i18nT('workflow:loop_end'),
+  showStatus: false,
+  version: '4811',
+  inputs: [
+    {
+      key: NodeInputKeyEnum.loopOutputArrayElement,
+      renderTypeList: [FlowNodeInputTypeEnum.reference],
+      valueType: WorkflowIOValueTypeEnum.any,
+      label: '',
+      required: true,
+      value: [],
+      showType: true
+    }
+  ],
+  outputs: []
+};

packages/global/core/workflow/template/system/loop/loopStart.ts

@@ -0,0 +1,34 @@
+import { FlowNodeInputTypeEnum, FlowNodeTypeEnum } from '../../../node/constant';
+import { FlowNodeTemplateType } from '../../../type/node.d';
+import {
+  FlowNodeTemplateTypeEnum,
+  NodeInputKeyEnum,
+  WorkflowIOValueTypeEnum
+} from '../../../constants';
+import { getHandleConfig } from '../../utils';
+import { i18nT } from '../../../../../../web/i18n/utils';
+
+export const LoopStartNode: FlowNodeTemplateType = {
+  id: FlowNodeTypeEnum.loopStart,
+  templateType: FlowNodeTemplateTypeEnum.systemInput,
+  flowNodeType: FlowNodeTypeEnum.loopStart,
+  sourceHandle: getHandleConfig(false, true, false, false),
+  targetHandle: getHandleConfig(false, false, false, false),
+  avatar: 'core/workflow/template/loopStart',
+  name: i18nT('workflow:loop_start'),
+  unique: true,
+  forbidDelete: true,
+  showStatus: false,
+  version: '4811',
+  inputs: [
+    {
+      key: NodeInputKeyEnum.loopArrayElement,
+      renderTypeList: [FlowNodeInputTypeEnum.hidden],
+      valueType: WorkflowIOValueTypeEnum.any,
+      label: '',
+      required: true,
+      value: ''
+    }
+  ],
+  outputs: []
+};

packages/global/core/workflow/type/io.d.ts

@@ -54,6 +54,7 @@ export type FlowNodeInputItemType = InputComponentPropsType & {
   // render components params
   canEdit?: boolean; // dynamic inputs
   isPro?: boolean; // Pro version field
+  showType?: boolean; // show data type
 };
 
 export type FlowNodeOutputItemType = {

packages/global/core/workflow/type/node.d.ts

@@ -95,6 +95,7 @@ export type NodeTemplateListType = {
 // react flow node type
 export type FlowNodeItemType = FlowNodeTemplateType & {
   nodeId: string;
+  parentNodeId?: string;
   isError?: boolean;
   debugResult?: {
     status: 'running' | 'success' | 'skipped' | 'failed';

packages/service/core/workflow/dispatch/index.ts

@@ -66,6 +66,9 @@ import {
   UserSelectInteractive
 } from '@fastgpt/global/core/workflow/template/system/userSelect/type';
 import { dispatchRunAppNode } from './plugin/runApp';
+import { dispatchLoop } from './tools/runLoop';
+import { dispatchLoopEnd } from './tools/runLoopEnd';
+import { dispatchLoopStart } from './tools/runLoopStart';
 
 const callbackMap: Record<FlowNodeTypeEnum, Function> = {
   [FlowNodeTypeEnum.workflowStart]: dispatchWorkflowStart,
@@ -91,6 +94,9 @@ const callbackMap: Record<FlowNodeTypeEnum, Function> = {
   [FlowNodeTypeEnum.customFeedback]: dispatchCustomFeedback,
   [FlowNodeTypeEnum.readFiles]: dispatchReadFiles,
   [FlowNodeTypeEnum.userSelect]: dispatchUserSelect,
+  [FlowNodeTypeEnum.loop]: dispatchLoop,
+  [FlowNodeTypeEnum.loopStart]: dispatchLoopStart,
+  [FlowNodeTypeEnum.loopEnd]: dispatchLoopEnd,
 
   // none
   [FlowNodeTypeEnum.systemConfig]: dispatchSystemConfig,

packages/service/core/workflow/dispatch/tools/runLoop.ts

@@ -0,0 +1,84 @@
+import { NodeInputKeyEnum, NodeOutputKeyEnum } from '@fastgpt/global/core/workflow/constants';
+import { FlowNodeTypeEnum } from '@fastgpt/global/core/workflow/node/constant';
+import {
+  DispatchNodeResultType,
+  ModuleDispatchProps
+} from '@fastgpt/global/core/workflow/runtime/type';
+import { dispatchWorkFlow } from '..';
+import { DispatchNodeResponseKeyEnum } from '@fastgpt/global/core/workflow/runtime/constants';
+import { ChatHistoryItemResType } from '@fastgpt/global/core/chat/type';
+
+type Props = ModuleDispatchProps<{
+  [NodeInputKeyEnum.loopInputArray]: Array<any>;
+  [NodeInputKeyEnum.loopFlow]: { childNodes: Array<string> };
+}>;
+type Response = DispatchNodeResultType<{
+  [NodeOutputKeyEnum.loopArray]: Array<any>;
+}>;
+
+export const dispatchLoop = async (props: Props): Promise<Response> => {
+  const {
+    params,
+    runtimeNodes,
+    user,
+    node: { name }
+  } = props;
+  const {
+    loopInputArray,
+    loopFlow: { childNodes }
+  } = params;
+  const runNodes = runtimeNodes.filter((node) => childNodes.includes(node.nodeId));
+  const outputArray = [];
+  const loopDetail: ChatHistoryItemResType[] = [];
+  let totalPoints = 0;
+
+  for await (const element of loopInputArray) {
+    const response = await dispatchWorkFlow({
+      ...props,
+      runtimeNodes: runNodes.map((node) =>
+        node.flowNodeType === FlowNodeTypeEnum.loopStart
+          ? {
+              ...node,
+              isEntry: true,
+              inputs: node.inputs.map((input) =>
+                input.key === NodeInputKeyEnum.loopArrayElement
+                  ? {
+                      ...input,
+                      value: element
+                    }
+                  : input
+              )
+            }
+          : {
+              ...node,
+              isEntry: false
+            }
+      )
+    });
+
+    const loopOutputValue = response.flowResponses.find(
+      (res) => res.moduleType === FlowNodeTypeEnum.loopEnd
+    )?.loopOutputValue;
+
+    outputArray.push(loopOutputValue);
+    loopDetail.push(...response.flowResponses);
+
+    totalPoints = response.flowUsages.reduce((acc, usage) => acc + usage.totalPoints, 0);
+  }
+
+  return {
+    [DispatchNodeResponseKeyEnum.nodeResponse]: {
+      totalPoints: totalPoints,
+      loopInput: loopInputArray,
+      loopResult: outputArray,
+      loopDetail: loopDetail
+    },
+    [DispatchNodeResponseKeyEnum.nodeDispatchUsages]: [
+      {
+        totalPoints: user.openaiAccount?.key ? 0 : totalPoints,
+        moduleName: name
+      }
+    ],
+    [NodeOutputKeyEnum.loopArray]: outputArray
+  };
+};

packages/service/core/workflow/dispatch/tools/runLoopEnd.ts

@@ -0,0 +1,21 @@
+import { NodeInputKeyEnum } from '@fastgpt/global/core/workflow/constants';
+import { DispatchNodeResponseKeyEnum } from '@fastgpt/global/core/workflow/runtime/constants';
+import {
+  DispatchNodeResultType,
+  ModuleDispatchProps
+} from '@fastgpt/global/core/workflow/runtime/type';
+
+type Props = ModuleDispatchProps<{
+  [NodeInputKeyEnum.loopOutputArrayElement]: any;
+}>;
+type Response = DispatchNodeResultType<{}>;
+
+export const dispatchLoopEnd = async (props: Props): Promise<Response> => {
+  const { params } = props;
+
+  return {
+    [DispatchNodeResponseKeyEnum.nodeResponse]: {
+      loopOutputValue: params.loopOutputArrayElement
+    }
+  };
+};