Support nested node interaction (#4503)

* feat: Add a new InteractiveContext type and update InteractiveBasicType, adding an optional context property to support more complex interaction state management.

* feat: Enhance workflow interactivity by adding InteractiveContext support and updating dispatch logic to manage nested contexts and entry nodes more effectively.

* feat: Refactor dispatchWorkFlow to utilize InteractiveContext for improved context management

* feat: Enhance entry node resolution by adding validation for entryNodeIds and recursive search in InteractiveContext

* feat: Remove workflowDepth from InteractiveContext and update recovery logic to utilize parentContext for improved context management

* feat: Update getWorkflowEntryNodeIds to use lastInteractive for improved context handling in runtime nodes

* feat: Add lastInteractive support to enhance context management across workflow components

* feat: Enhance interactive workflow by adding stopForInteractive flag and improving memory edge validation in runtime logic

* feat: Refactor InteractiveContext by removing interactiveAppId and updating runtime edge handling in dispatchRunApp for improved context management

* feat: Simplify runtime node and edge initialization in dispatchRunApp by using ternary operators for improved readability and maintainability

* feat: Improve memory edge validation in initWorkflowEdgeStatus by adding detailed comments for better understanding of subset checks and recursive context searching

* feat: Remove commented-out current level information from InteractiveContext for cleaner code and improved readability

* feat: Simplify stopForInteractive check in dispatchWorkFlow for improved code clarity and maintainability

* feat: Remove stopForInteractive handling and related references for improved code clarity and maintainability

* feat: Add interactive response handling in dispatchRunAppNode for enhanced workflow interactivity

* feat: Add context property to InteractiveBasicType and InteractiveNodeType for improved interactivity management

* feat: remove comments

* feat: Remove the node property from ChatDispatchProps to simplify type definitions

* feat: Remove workflowInteractiveResponse from dispatchRunAppNode for cleaner code

* feat: Refactor interactive value handling in chat history processing for improved clarity

* feat: Simplify initWorkflowEdgeStatus logic for better readability and maintainability

* feat: Add workflowInteractiveResponse to dispatchWorkFlow for enhanced functionality

* feat: Enhance interactive response handling with nested children support

* feat: Remove commented-out code for interactive node handling to improve clarity

* feat: remove  InteractiveContext type

* feat: Refactor UserSelectInteractive and UserInputInteractive params for improved structure and clarity

* feat: remove

* feat: The front end supports extracting the deepest interaction parameters to enhance interaction processing

* feat: The front end supports extracting the deepest interaction parameters to enhance interaction processing

* fix: handle undefined interactive values in runtimeEdges and runtimeNodes initialization

* fix: handle undefined interactive values in runtimeNodes and runtimeEdges initialization

* fix: update runtimeNodes and runtimeEdges initialization to use last interactive value

* fix: remove unused imports and replace getLastInteractiveValue with lastInteractive in runtimeEdges initialization

* fix: import WorkflowInteractiveResponseType and handle lastInteractive as undefined in chatTest

* feat: implement extractDeepestInteractive function and refactor usage in AIResponseBox and ChatBox utils

* fix: refactor initWorkflowEdgeStatus and getWorkflowEntryNodeIds calls in dispatchRunAppNode for recovery handling

* fix: ensure lastInteractive is handled consistently as undefined in runtimeEdges and runtimeNodes initialization

* fix: update dispatchFormInput and dispatchUserSelect to use lastInteractive consistently

* fix: update condition checks in dispatchFormInput and dispatchUserSelect to ensure lastInteractive type is validated correctly

* fix: refactor dispatchRunAppNode to replace isRecovery with childrenInteractive for improved clarity in runtimeNodes and runtimeEdges initialization

* refactor: streamline runtimeNodes and runtimeEdges initialization in dispatchRunAppNode for improved readability and maintainability

* fix: update rewriteNodeOutputByHistories function to accept runtimeNodes and interactive as parameters for improved clarity

* fix: simplify interactiveResponse assignment in dispatchWorkFlow for improved clarity

* fix: update entryNodeIds check in getWorkflowEntryNodeIds to ensure it's an array for improved reliability

Author: sd0ric4

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

@@ -23,7 +23,7 @@ import { WorkflowResponseType } from '../../../../service/core/workflow/dispatch
 import { AiChatQuoteRoleType } from '../template/system/aiChat/type';
 import { LafAccountType, OpenaiAccountType } from '../../../support/user/team/type';
 import { CompletionFinishReason } from '../../ai/type';
-
+import { WorkflowInteractiveResponseType } from '../template/system/interactive/type';
 export type ExternalProviderType = {
   openaiAccount?: OpenaiAccountType;
   externalWorkflowVariables?: Record<string, string>;
@@ -55,6 +55,7 @@ export type ChatDispatchProps = {
   variables: Record<string, any>; // global variable
   query: UserChatItemValueItemType[]; // trigger query
   chatConfig: AppSchema['chatConfig'];
+  lastInteractive?: WorkflowInteractiveResponseType; // last interactive response
   stream: boolean;
   maxRunTimes: number;
   isToolCall?: boolean;

packages/global/core/workflow/runtime/utils.ts

@@ -10,7 +10,19 @@ import { FlowNodeOutputItemType, ReferenceValueType } from '../type/io';
 import { ChatItemType, NodeOutputItemType } from '../../../core/chat/type';
 import { ChatItemValueTypeEnum, ChatRoleEnum } from '../../../core/chat/constants';
 import { replaceVariable, valToStr } from '../../../common/string/tools';
-
+import {
+  InteractiveNodeResponseType,
+  WorkflowInteractiveResponseType
+} from '../template/system/interactive/type';
+
+export const extractDeepestInteractive = (
+  interactive: WorkflowInteractiveResponseType
+): WorkflowInteractiveResponseType => {
+  if (interactive?.type === 'childrenInteractive' && interactive.params?.childrenResponse) {
+    return extractDeepestInteractive(interactive.params.childrenResponse);
+  }
+  return interactive;
+};
 export const getMaxHistoryLimitFromNodes = (nodes: StoreNodeItemType[]): number => {
   let limit = 10;
   nodes.forEach((node) => {
@@ -48,6 +60,10 @@ export const getLastInteractiveValue = (histories: ChatItemType[]) => {
       return null;
     }
 
+    if (lastValue.interactive.type === 'childrenInteractive') {
+      return lastValue.interactive;
+    }
+
     // Check is user select
     if (
       lastValue.interactive.type === 'userSelect' &&
@@ -66,34 +82,25 @@ export const getLastInteractiveValue = (histories: ChatItemType[]) => {
 };
 
 export const initWorkflowEdgeStatus = (
-  edges: StoreEdgeItemType[] | RuntimeEdgeItemType[],
-  histories?: ChatItemType[]
+  edges: StoreEdgeItemType[],
+  lastInteractive?: WorkflowInteractiveResponseType
 ): RuntimeEdgeItemType[] => {
-  // If there is a history, use the last interactive value
-  if (histories && histories.length > 0) {
-    const memoryEdges = getLastInteractiveValue(histories)?.memoryEdges;
-
+  if (lastInteractive) {
+    const memoryEdges = lastInteractive.memoryEdges || [];
     if (memoryEdges && memoryEdges.length > 0) {
       return memoryEdges;
     }
   }
 
-  return (
-    edges?.map((edge) => ({
-      ...edge,
-      status: 'waiting'
-    })) || []
-  );
+  return edges?.map((edge) => ({ ...edge, status: 'waiting' })) || [];
 };
 
 export const getWorkflowEntryNodeIds = (
   nodes: (StoreNodeItemType | RuntimeNodeItemType)[],
-  histories?: ChatItemType[]
+  lastInteractive?: WorkflowInteractiveResponseType
 ) => {
-  // If there is a history, use the last interactive entry node
-  if (histories && histories.length > 0) {
-    const entryNodeIds = getLastInteractiveValue(histories)?.entryNodeIds;
-
+  if (lastInteractive) {
+    const entryNodeIds = lastInteractive.entryNodeIds || [];
     if (Array.isArray(entryNodeIds) && entryNodeIds.length > 0) {
       return entryNodeIds;
     }
@@ -396,10 +403,10 @@ export const textAdaptGptResponse = ({
 
 /* Update runtimeNode's outputs with interactive data from history */
 export function rewriteNodeOutputByHistories(
-  histories: ChatItemType[],
-  runtimeNodes: RuntimeNodeItemType[]
+  runtimeNodes: RuntimeNodeItemType[],
+  lastInteractive?: InteractiveNodeResponseType
 ) {
-  const interactive = getLastInteractiveValue(histories);
+  const interactive = lastInteractive;
   if (!interactive?.nodeOutputs) {
     return runtimeNodes;
   }

packages/global/core/workflow/template/system/interactive/type.d.ts

@@ -1,6 +1,5 @@
 import type { NodeOutputItemType } from '../../../../chat/type';
 import type { FlowNodeOutputItemType } from '../../../type/io';
-import type { RuntimeEdgeItemType } from '../../../runtime/type';
 import { FlowNodeInputTypeEnum } from 'core/workflow/node/constant';
 import { WorkflowIOValueTypeEnum } from 'core/workflow/constants';
 import type { ChatCompletionMessageParam } from '../../../../ai/type';
@@ -9,7 +8,6 @@ type InteractiveBasicType = {
   entryNodeIds: string[];
   memoryEdges: RuntimeEdgeItemType[];
   nodeOutputs: NodeOutputItemType[];
-
   toolParams?: {
     entryNodeIds: string[]; // 记录工具中，交互节点的 Id，而不是起始工作流的入口
     memoryMessages: ChatCompletionMessageParam[]; // 这轮工具中，产生的新的 messages
@@ -23,13 +21,21 @@ type InteractiveNodeType = {
   nodeOutputs?: NodeOutputItemType[];
 };
 
+type ChildrenInteractive = InteractiveNodeType & {
+  type: 'childrenInteractive';
+  params: {
+    childrenResponse?: WorkflowInteractiveResponseType;
+  };
+};
+
 export type UserSelectOptionItemType = {
   key: string;
   value: string;
 };
 type UserSelectInteractive = InteractiveNodeType & {
   type: 'userSelect';
   params: {
+    childrenResponse?: WorkflowInteractiveResponseType;
     description: string;
     userSelectOptions: UserSelectOptionItemType[];
     userSelectedVal?: string;
@@ -57,10 +63,15 @@ export type UserInputFormItemType = {
 type UserInputInteractive = InteractiveNodeType & {
   type: 'userInput';
   params: {
+    childrenResponse?: WorkflowInteractiveResponseType;
     description: string;
     inputForm: UserInputFormItemType[];
     submitted?: boolean;
   };
 };
-export type InteractiveNodeResponseType = UserSelectInteractive | UserInputInteractive;
+
+export type InteractiveNodeResponseType =
+  | UserSelectInteractive
+  | UserInputInteractive
+  | ChildrenInteractive;
 export type WorkflowInteractiveResponseType = InteractiveBasicType & InteractiveNodeResponseType;

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

@@ -374,7 +374,7 @@ export async function dispatchWorkFlow(data: Props): Promise<DispatchFlowRespons
     };
 
     // Tool call, not need interactive response
-    if (!props.isToolCall) {
+    if (!props.isToolCall && !props.runningAppInfo.isChildApp) {
       props.workflowStreamResponse?.({
         event: SseResponseEventEnum.interactive,
         data: { interactive: interactiveResult }
@@ -721,7 +721,9 @@ export async function dispatchWorkFlow(data: Props): Promise<DispatchFlowRespons
           entryNodeIds: nodeInteractiveResponse.entryNodeIds,
           interactiveResponse: nodeInteractiveResponse.interactiveResponse
         });
-        chatAssistantResponse.push(interactiveAssistant);
+        if (!props.runningAppInfo.isChildApp) {
+          chatAssistantResponse.push(interactiveAssistant);
+        }
         return interactiveAssistant.interactive;
       }
     })();

packages/service/core/workflow/dispatch/interactive/formInput.ts

@@ -10,7 +10,6 @@ import type {
   UserInputInteractive
 } from '@fastgpt/global/core/workflow/template/system/interactive/type';
 import { addLog } from '../../../../common/system/log';
-import { getLastInteractiveValue } from '@fastgpt/global/core/workflow/runtime/utils';
 
 type Props = ModuleDispatchProps<{
   [NodeInputKeyEnum.description]: string;
@@ -29,13 +28,13 @@ export const dispatchFormInput = async (props: Props): Promise<FormInputResponse
     histories,
     node,
     params: { description, userInputForms },
-    query
+    query,
+    lastInteractive
   } = props;
   const { isEntry } = node;
-  const interactive = getLastInteractiveValue(histories);
 
   // Interactive node is not the entry node, return interactive result
-  if (!isEntry || interactive?.type !== 'userInput') {
+  if (!isEntry || lastInteractive?.type !== 'userInput') {
     return {
       [DispatchNodeResponseKeyEnum.interactive]: {
         type: 'userInput',

packages/service/core/workflow/dispatch/interactive/userSelect.ts

@@ -10,7 +10,6 @@ import type {
   UserSelectOptionItemType
 } from '@fastgpt/global/core/workflow/template/system/interactive/type';
 import { chatValue2RuntimePrompt } from '@fastgpt/global/core/chat/adapt';
-import { getLastInteractiveValue } from '@fastgpt/global/core/workflow/runtime/utils';
 
 type Props = ModuleDispatchProps<{
   [NodeInputKeyEnum.description]: string;
@@ -27,13 +26,13 @@ export const dispatchUserSelect = async (props: Props): Promise<UserSelectRespon
     histories,
     node,
     params: { description, userSelectOptions },
-    query
+    query,
+    lastInteractive
   } = props;
   const { nodeId, isEntry } = node;
-  const interactive = getLastInteractiveValue(histories);
 
   // Interactive node is not the entry node, return interactive result
-  if (!isEntry || interactive?.type !== 'userSelect') {
+  if (!isEntry || lastInteractive?.type !== 'userSelect') {
     return {
       [DispatchNodeResponseKeyEnum.interactive]: {
         type: 'userSelect',

packages/service/core/workflow/dispatch/plugin/runApp.ts

@@ -18,6 +18,7 @@ import { authAppByTmbId } from '../../../../support/permission/app/auth';
 import { ReadPermissionVal } from '@fastgpt/global/support/permission/constant';
 import { getAppVersionById } from '../../../app/version/controller';
 import { parseUrlToFileType } from '@fastgpt/global/common/file/tools';
+import { ChildrenInteractive } from '@fastgpt/global/core/workflow/template/system/interactive/type';
 
 type Props = ModuleDispatchProps<{
   [NodeInputKeyEnum.userChatInput]: string;
@@ -27,6 +28,7 @@ type Props = ModuleDispatchProps<{
   [NodeInputKeyEnum.fileUrlList]?: string[];
 }>;
 type Response = DispatchNodeResultType<{
+  [DispatchNodeResponseKeyEnum.interactive]?: ChildrenInteractive;
   [NodeOutputKeyEnum.answerText]: string;
   [NodeOutputKeyEnum.history]: ChatItemType[];
 }>;
@@ -36,6 +38,7 @@ export const dispatchRunAppNode = async (props: Props): Promise<Response> => {
     runningAppInfo,
     histories,
     query,
+    lastInteractive,
     node: { pluginId: appId, version },
     workflowStreamResponse,
     params,
@@ -100,31 +103,38 @@ export const dispatchRunAppNode = async (props: Props): Promise<Response> => {
     appId: String(appData._id)
   };
 
-  const { flowResponses, flowUsages, assistantResponses, runTimes } = await dispatchWorkFlow({
-    ...props,
-    // Rewrite stream mode
-    ...(system_forbid_stream
-      ? {
-          stream: false,
-          workflowStreamResponse: undefined
-        }
-      : {}),
-    runningAppInfo: {
-      id: String(appData._id),
-      teamId: String(appData.teamId),
-      tmbId: String(appData.tmbId),
-      isChildApp: true
-    },
-    runtimeNodes: storeNodes2RuntimeNodes(nodes, getWorkflowEntryNodeIds(nodes)),
-    runtimeEdges: initWorkflowEdgeStatus(edges),
-    histories: chatHistories,
-    variables: childrenRunVariables,
-    query: runtimePrompt2ChatsValue({
-      files: userInputFiles,
-      text: userChatInput
-    }),
-    chatConfig
-  });
+  const childrenInteractive = lastInteractive?.params?.childrenResponse;
+  const entryNodeIds = getWorkflowEntryNodeIds(nodes, childrenInteractive || undefined);
+  const runtimeNodes = storeNodes2RuntimeNodes(nodes, entryNodeIds);
+  const runtimeEdges = initWorkflowEdgeStatus(edges, childrenInteractive);
+  const theQuery = childrenInteractive
+    ? query
+    : runtimePrompt2ChatsValue({ files: userInputFiles, text: userChatInput });
+
+  const { flowResponses, flowUsages, assistantResponses, runTimes, workflowInteractiveResponse } =
+    await dispatchWorkFlow({
+      ...props,
+      lastInteractive: childrenInteractive,
+      // Rewrite stream mode
+      ...(system_forbid_stream
+        ? {
+            stream: false,
+            workflowStreamResponse: undefined
+          }
+        : {}),
+      runningAppInfo: {
+        id: String(appData._id),
+        teamId: String(appData.teamId),
+        tmbId: String(appData.tmbId),
+        isChildApp: true
+      },
+      runtimeNodes,
+      runtimeEdges,
+      histories: chatHistories,
+      variables: childrenRunVariables,
+      query: theQuery,
+      chatConfig
+    });
 
   const completeMessages = chatHistories.concat([
     {
@@ -142,6 +152,14 @@ export const dispatchRunAppNode = async (props: Props): Promise<Response> => {
   const usagePoints = flowUsages.reduce((sum, item) => sum + (item.totalPoints || 0), 0);
 
   return {
+    [DispatchNodeResponseKeyEnum.interactive]: workflowInteractiveResponse
+      ? {
+          type: 'childrenInteractive',
+          params: {
+            childrenResponse: workflowInteractiveResponse
+          }
+        }
+      : undefined,
     assistantResponses: system_forbid_stream ? [] : assistantResponses,
     [DispatchNodeResponseKeyEnum.runTimes]: runTimes,
     [DispatchNodeResponseKeyEnum.nodeResponse]: {

projects/app/src/components/core/chat/ChatContainer/ChatBox/utils.ts

@@ -6,6 +6,7 @@ import {
 import { ChatBoxInputType, UserInputFileItemType } from './type';
 import { getFileIcon } from '@fastgpt/global/common/file/icon';
 import { ChatItemValueTypeEnum, ChatStatusEnum } from '@fastgpt/global/core/chat/constants';
+import { extractDeepestInteractive } from '@fastgpt/global/core/workflow/runtime/utils';
 
 export const formatChatValue2InputType = (value?: ChatItemValueItemType[]): ChatBoxInputType => {
   if (!value) {
@@ -84,29 +85,29 @@ export const setUserSelectResultToHistories = (
         !val.interactive
       )
         return val;
-
-      if (val.interactive.type === 'userSelect') {
+      const finalInteractive = extractDeepestInteractive(val.interactive);
+      if (finalInteractive.type === 'userSelect') {
         return {
           ...val,
           interactive: {
-            ...val.interactive,
+            ...finalInteractive,
             params: {
-              ...val.interactive.params,
-              userSelectedVal: val.interactive.params.userSelectOptions.find(
-                (item) => item.value === interactiveVal
+              ...finalInteractive.params,
+              userSelectedVal: finalInteractive.params.userSelectOptions.find(
+                (item: { value: string }) => item.value === interactiveVal
               )?.value
             }
           }
         };
       }
 
-      if (val.interactive.type === 'userInput') {
+      if (finalInteractive.type === 'userInput') {
         return {
           ...val,
           interactive: {
-            ...val.interactive,
+            ...finalInteractive,
             params: {
-              ...val.interactive.params,
+              ...finalInteractive.params,
               submitted: true
             }
           }