Feature/Update Loop Agentflow (#4957)

* Feature: Update Loop Agentflow to include fallback message and version increment to 1.1

- Added a new input parameter 'fallbackMessage' to the Loop Agentflow for displaying a message when the loop count is exceeded.
- Incremented the version of Loop Agentflow from 1.0 to 1.1.
- Updated the processing logic to handle the fallback message appropriately when the maximum loop count is reached.

* - Introduced a new input parameter 'loopUpdateState' to allow updating the runtime state during workflow execution.
- Added a method to list runtime state keys for dynamic state management.
- Implemented logic to retrieve and utilize the current loop count in variable resolution.
- Updated the Loop Agentflow output to reflect the new state and final output content.

packages/components/nodes/agentflow/Loop/Loop.ts

@@ -1,4 +1,5 @@
 import { ICommonObject, INode, INodeData, INodeOptionsValue, INodeParams } from '../../../src/Interface'
+import { updateFlowState } from '../utils'
 
 class Loop_Agentflow implements INode {
     label: string
@@ -19,7 +20,7 @@ class Loop_Agentflow implements INode {
     constructor() {
         this.label = 'Loop'
         this.name = 'loopAgentflow'
-        this.version = 1.0
+        this.version = 1.1
         this.type = 'Loop'
         this.category = 'Agent Flows'
         this.description = 'Loop back to a previous node'
@@ -40,6 +41,40 @@ class Loop_Agentflow implements INode {
                 name: 'maxLoopCount',
                 type: 'number',
                 default: 5
+            },
+            {
+                label: 'Fallback Message',
+                name: 'fallbackMessage',
+                type: 'string',
+                description: 'Message to display if the loop count is exceeded',
+                placeholder: 'Enter your fallback message here',
+                rows: 4,
+                acceptVariable: true,
+                optional: true
+            },
+            {
+                label: 'Update Flow State',
+                name: 'loopUpdateState',
+                description: 'Update runtime state during the execution of the workflow',
+                type: 'array',
+                optional: true,
+                acceptVariable: true,
+                array: [
+                    {
+                        label: 'Key',
+                        name: 'key',
+                        type: 'asyncOptions',
+                        loadMethod: 'listRuntimeStateKeys',
+                        freeSolo: true
+                    },
+                    {
+                        label: 'Value',
+                        name: 'value',
+                        type: 'string',
+                        acceptVariable: true,
+                        acceptNodeOutputAsVariable: true
+                    }
+                ]
             }
         ]
     }
@@ -58,12 +93,20 @@ class Loop_Agentflow implements INode {
                 })
             }
             return returnOptions
+        },
+        async listRuntimeStateKeys(_: INodeData, options: ICommonObject): Promise<INodeOptionsValue[]> {
+            const previousNodes = options.previousNodes as ICommonObject[]
+            const startAgentflowNode = previousNodes.find((node) => node.name === 'startAgentflow')
+            const state = startAgentflowNode?.inputs?.startState as ICommonObject[]
+            return state.map((item) => ({ label: item.key, name: item.key }))
         }
     }
 
     async run(nodeData: INodeData, _: string, options: ICommonObject): Promise<any> {
         const loopBackToNode = nodeData.inputs?.loopBackToNode as string
         const _maxLoopCount = nodeData.inputs?.maxLoopCount as string
+        const fallbackMessage = nodeData.inputs?.fallbackMessage as string
+        const _loopUpdateState = nodeData.inputs?.loopUpdateState
 
         const state = options.agentflowRuntime?.state as ICommonObject
 
@@ -75,16 +118,34 @@ class Loop_Agentflow implements INode {
             maxLoopCount: _maxLoopCount ? parseInt(_maxLoopCount) : 5
         }
 
+        const finalOutput = 'Loop back to ' + `${loopBackToNodeLabel} (${loopBackToNodeId})`
+
+        // Update flow state if needed
+        let newState = { ...state }
+        if (_loopUpdateState && Array.isArray(_loopUpdateState) && _loopUpdateState.length > 0) {
+            newState = updateFlowState(state, _loopUpdateState)
+        }
+
+        // Process template variables in state
+        if (newState && Object.keys(newState).length > 0) {
+            for (const key in newState) {
+                if (newState[key].toString().includes('{{ output }}')) {
+                    newState[key] = finalOutput
+                }
+            }
+        }
+
         const returnOutput = {
             id: nodeData.id,
             name: this.name,
             input: data,
             output: {
-                content: 'Loop back to ' + `${loopBackToNodeLabel} (${loopBackToNodeId})`,
+                content: finalOutput,
                 nodeID: loopBackToNodeId,
-                maxLoopCount: _maxLoopCount ? parseInt(_maxLoopCount) : 5
+                maxLoopCount: _maxLoopCount ? parseInt(_maxLoopCount) : 5,
+                fallbackMessage
             },
-            state
+            state: newState
         }
 
         return returnOutput