change agent/chain with memory to use runnable

packages/components/nodes/agents/ConversationalAgent/ConversationalAgent.ts

@@ -1,11 +1,14 @@
-import { ICommonObject, INode, INodeData, INodeParams } from '../../../src/Interface'
-import { initializeAgentExecutorWithOptions, AgentExecutor, InitializeAgentExecutorOptions } from 'langchain/agents'
 import { Tool } from 'langchain/tools'
-import { BaseChatMemory } from 'langchain/memory'
-import { getBaseClasses, mapChatHistory } from '../../../src/utils'
 import { BaseChatModel } from 'langchain/chat_models/base'
 import { flatten } from 'lodash'
-import { additionalCallbacks } from '../../../src/handler'
+import { AgentStep, BaseMessage, ChainValues, AIMessage, HumanMessage } from 'langchain/schema'
+import { RunnableSequence } from 'langchain/schema/runnable'
+import { getBaseClasses } from '../../../src/utils'
+import { ConsoleCallbackHandler, CustomChainHandler, additionalCallbacks } from '../../../src/handler'
+import { FlowiseMemory, ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { AgentExecutor } from '../../../src/agents'
+import { ChatConversationalAgent } from 'langchain/agents'
+import { renderTemplate } from '@langchain/core/prompts'
 
 const DEFAULT_PREFIX = `Assistant is a large language model trained by OpenAI.
 
@@ -15,6 +18,15 @@ Assistant is constantly learning and improving, and its capabilities are constan
 
 Overall, Assistant is a powerful system that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.`
 
+const TEMPLATE_TOOL_RESPONSE = `TOOL RESPONSE:
+---------------------
+{observation}
+
+USER'S INPUT
+--------------------
+
+Okay, so what is the response to my last comment? If using information obtained from the tools you must mention it explicitly without mentioning the tool names - I have forgotten all TOOL RESPONSES! Remember to respond with a markdown code snippet of a json blob with a single action, and NOTHING else.`
+
 class ConversationalAgent_Agents implements INode {
     label: string
     name: string
@@ -25,8 +37,9 @@ class ConversationalAgent_Agents implements INode {
     category: string
     baseClasses: string[]
     inputs: INodeParams[]
+    sessionId?: string
 
-    constructor() {
+    constructor(fields?: { sessionId?: string }) {
         this.label = 'Conversational Agent'
         this.name = 'conversationalAgent'
         this.version = 2.0
@@ -43,7 +56,7 @@ class ConversationalAgent_Agents implements INode {
                 list: true
             },
             {
-                label: 'Language Model',
+                label: 'Chat Model',
                 name: 'model',
                 type: 'BaseChatModel'
             },
@@ -62,52 +75,114 @@ class ConversationalAgent_Agents implements INode {
                 additionalParams: true
             }
         ]
+        this.sessionId = fields?.sessionId
     }
 
-    async init(nodeData: INodeData): Promise<any> {
-        const model = nodeData.inputs?.model as BaseChatModel
-        let tools = nodeData.inputs?.tools as Tool[]
-        tools = flatten(tools)
-        const memory = nodeData.inputs?.memory as BaseChatMemory
-        const systemMessage = nodeData.inputs?.systemMessage as string
-
-        const obj: InitializeAgentExecutorOptions = {
-            agentType: 'chat-conversational-react-description',
-            verbose: process.env.DEBUG === 'true' ? true : false
-        }
-
-        const agentArgs: any = {}
-        if (systemMessage) {
-            agentArgs.systemMessage = systemMessage
-        }
-
-        if (Object.keys(agentArgs).length) obj.agentArgs = agentArgs
-
-        const executor = await initializeAgentExecutorWithOptions(tools, model, obj)
-        executor.memory = memory
-        return executor
+    async init(nodeData: INodeData, input: string, options: ICommonObject): Promise<any> {
+        return prepareAgent(nodeData, { sessionId: this.sessionId, chatId: options.chatId, input }, options.chatHistory)
     }
 
     async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
-        const executor = nodeData.instance as AgentExecutor
-        const memory = nodeData.inputs?.memory as BaseChatMemory
-
-        if (options && options.chatHistory) {
-            const chatHistoryClassName = memory.chatHistory.constructor.name
-            // Only replace when its In-Memory
-            if (chatHistoryClassName && chatHistoryClassName === 'ChatMessageHistory') {
-                memory.chatHistory = mapChatHistory(options)
-                executor.memory = memory
-            }
-        }
-
-        ;(executor.memory as any).returnMessages = true // Return true for BaseChatModel
+        const memory = nodeData.inputs?.memory as FlowiseMemory
+        const executor = await prepareAgent(nodeData, { sessionId: this.sessionId, chatId: options.chatId, input }, options.chatHistory)
 
+        const loggerHandler = new ConsoleCallbackHandler(options.logger)
         const callbacks = await additionalCallbacks(nodeData, options)
 
-        const result = await executor.call({ input }, [...callbacks])
-        return result?.output
+        let res: ChainValues = {}
+
+        if (options.socketIO && options.socketIOClientId) {
+            const handler = new CustomChainHandler(options.socketIO, options.socketIOClientId)
+            res = await executor.invoke({ input }, { callbacks: [loggerHandler, handler, ...callbacks] })
+        } else {
+            res = await executor.invoke({ input }, { callbacks: [loggerHandler, ...callbacks] })
+        }
+
+        await memory.addChatMessages(
+            [
+                {
+                    text: input,
+                    type: 'userMessage'
+                },
+                {
+                    text: res?.output,
+                    type: 'apiMessage'
+                }
+            ],
+            this.sessionId
+        )
+
+        return res?.output
     }
 }
 
+const prepareAgent = async (
+    nodeData: INodeData,
+    flowObj: { sessionId?: string; chatId?: string; input?: string },
+    chatHistory: IMessage[] = []
+) => {
+    const model = nodeData.inputs?.model as BaseChatModel
+    let tools = nodeData.inputs?.tools as Tool[]
+    tools = flatten(tools)
+    const memory = nodeData.inputs?.memory as FlowiseMemory
+    const systemMessage = nodeData.inputs?.systemMessage as string
+    const memoryKey = memory.memoryKey ? memory.memoryKey : 'chat_history'
+    const inputKey = memory.inputKey ? memory.inputKey : 'input'
+
+    /** Bind a stop token to the model */
+    const modelWithStop = model.bind({
+        stop: ['\nObservation']
+    })
+
+    const outputParser = ChatConversationalAgent.getDefaultOutputParser({
+        llm: model,
+        toolNames: tools.map((tool) => tool.name)
+    })
+
+    const prompt = ChatConversationalAgent.createPrompt(tools, {
+        systemMessage: systemMessage ? systemMessage : DEFAULT_PREFIX,
+        outputParser
+    })
+
+    const runnableAgent = RunnableSequence.from([
+        {
+            [inputKey]: (i: { input: string; steps: AgentStep[] }) => i.input,
+            agent_scratchpad: async (i: { input: string; steps: AgentStep[] }) => await constructScratchPad(i.steps),
+            [memoryKey]: async (_: { input: string; steps: AgentStep[] }) => {
+                const messages = (await memory.getChatMessages(flowObj?.sessionId, true, chatHistory)) as BaseMessage[]
+                return messages ?? []
+            }
+        },
+        prompt,
+        modelWithStop,
+        outputParser
+    ])
+
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnableAgent,
+        tools,
+        sessionId: flowObj?.sessionId,
+        chatId: flowObj?.chatId,
+        input: flowObj?.input,
+        verbose: process.env.DEBUG === 'true' ? true : false
+    })
+
+    return executor
+}
+
+const constructScratchPad = async (steps: AgentStep[]): Promise<BaseMessage[]> => {
+    const thoughts: BaseMessage[] = []
+    for (const step of steps) {
+        thoughts.push(new AIMessage(step.action.log))
+        thoughts.push(
+            new HumanMessage(
+                renderTemplate(TEMPLATE_TOOL_RESPONSE, 'f-string', {
+                    observation: step.observation
+                })
+            )
+        )
+    }
+    return thoughts
+}
+
 module.exports = { nodeClass: ConversationalAgent_Agents }

packages/components/nodes/agents/ConversationalRetrievalAgent/ConversationalRetrievalAgent.ts

@@ -1,9 +1,14 @@
-import { ICommonObject, INode, INodeData, INodeParams } from '../../../src/Interface'
-import { initializeAgentExecutorWithOptions, AgentExecutor } from 'langchain/agents'
-import { getBaseClasses, mapChatHistory } from '../../../src/utils'
+import { ChainValues, AgentStep, BaseMessage } from 'langchain/schema'
 import { flatten } from 'lodash'
-import { BaseChatMemory } from 'langchain/memory'
+import { ChatOpenAI } from 'langchain/chat_models/openai'
+import { ChatPromptTemplate, MessagesPlaceholder } from 'langchain/prompts'
+import { formatToOpenAIFunction } from 'langchain/tools'
+import { RunnableSequence } from 'langchain/schema/runnable'
+import { FlowiseMemory, ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
+import { getBaseClasses } from '../../../src/utils'
 import { ConsoleCallbackHandler, CustomChainHandler, additionalCallbacks } from '../../../src/handler'
+import { OpenAIFunctionsAgentOutputParser } from 'langchain/agents/openai/output_parser'
+import { AgentExecutor, formatAgentSteps } from '../../../src/agents'
 
 const defaultMessage = `Do your best to answer the questions. Feel free to use any tools available to look up relevant information, only if necessary.`
 
@@ -17,8 +22,9 @@ class ConversationalRetrievalAgent_Agents implements INode {
     category: string
     baseClasses: string[]
     inputs: INodeParams[]
+    sessionId?: string
 
-    constructor() {
+    constructor(fields?: { sessionId?: string }) {
         this.label = 'Conversational Retrieval Agent'
         this.name = 'conversationalRetrievalAgent'
         this.version = 3.0
@@ -54,55 +60,96 @@ class ConversationalRetrievalAgent_Agents implements INode {
                 additionalParams: true
             }
         ]
+        this.sessionId = fields?.sessionId
     }
 
-    async init(nodeData: INodeData): Promise<any> {
-        const model = nodeData.inputs?.model
-        const memory = nodeData.inputs?.memory as BaseChatMemory
-        const systemMessage = nodeData.inputs?.systemMessage as string
-
-        let tools = nodeData.inputs?.tools
-        tools = flatten(tools)
-
-        const executor = await initializeAgentExecutorWithOptions(tools, model, {
-            agentType: 'openai-functions',
-            verbose: process.env.DEBUG === 'true' ? true : false,
-            agentArgs: {
-                prefix: systemMessage ?? defaultMessage
-            },
-            returnIntermediateSteps: true
-        })
-        executor.memory = memory
-        return executor
+    async init(nodeData: INodeData, input: string, options: ICommonObject): Promise<any> {
+        return prepareAgent(nodeData, { sessionId: this.sessionId, chatId: options.chatId, input }, options.chatHistory)
     }
 
     async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
-        const executor = nodeData.instance as AgentExecutor
-
-        if (executor.memory) {
-            ;(executor.memory as any).memoryKey = 'chat_history'
-            ;(executor.memory as any).outputKey = 'output'
-            ;(executor.memory as any).returnMessages = true
-
-            const chatHistoryClassName = (executor.memory as any).chatHistory.constructor.name
-            // Only replace when its In-Memory
-            if (chatHistoryClassName && chatHistoryClassName === 'ChatMessageHistory') {
-                ;(executor.memory as any).chatHistory = mapChatHistory(options)
-            }
-        }
+        const memory = nodeData.inputs?.memory as FlowiseMemory
+        const executor = prepareAgent(nodeData, { sessionId: this.sessionId, chatId: options.chatId, input }, options.chatHistory)
 
         const loggerHandler = new ConsoleCallbackHandler(options.logger)
         const callbacks = await additionalCallbacks(nodeData, options)
 
+        let res: ChainValues = {}
+
         if (options.socketIO && options.socketIOClientId) {
             const handler = new CustomChainHandler(options.socketIO, options.socketIOClientId)
-            const result = await executor.call({ input }, [loggerHandler, handler, ...callbacks])
-            return result?.output
+            res = await executor.invoke({ input }, { callbacks: [loggerHandler, handler, ...callbacks] })
         } else {
-            const result = await executor.call({ input }, [loggerHandler, ...callbacks])
-            return result?.output
+            res = await executor.invoke({ input }, { callbacks: [loggerHandler, ...callbacks] })
         }
+
+        await memory.addChatMessages(
+            [
+                {
+                    text: input,
+                    type: 'userMessage'
+                },
+                {
+                    text: res?.output,
+                    type: 'apiMessage'
+                }
+            ],
+            this.sessionId
+        )
+
+        return res?.output
     }
 }
 
+const prepareAgent = (
+    nodeData: INodeData,
+    flowObj: { sessionId?: string; chatId?: string; input?: string },
+    chatHistory: IMessage[] = []
+) => {
+    const model = nodeData.inputs?.model as ChatOpenAI
+    const memory = nodeData.inputs?.memory as FlowiseMemory
+    const systemMessage = nodeData.inputs?.systemMessage as string
+    let tools = nodeData.inputs?.tools
+    tools = flatten(tools)
+    const memoryKey = memory.memoryKey ? memory.memoryKey : 'chat_history'
+    const inputKey = memory.inputKey ? memory.inputKey : 'input'
+
+    const prompt = ChatPromptTemplate.fromMessages([
+        ['ai', systemMessage ? systemMessage : defaultMessage],
+        new MessagesPlaceholder(memoryKey),
+        ['human', `{${inputKey}}`],
+        new MessagesPlaceholder('agent_scratchpad')
+    ])
+
+    const modelWithFunctions = model.bind({
+        functions: [...tools.map((tool: any) => formatToOpenAIFunction(tool))]
+    })
+
+    const runnableAgent = RunnableSequence.from([
+        {
+            [inputKey]: (i: { input: string; steps: AgentStep[] }) => i.input,
+            agent_scratchpad: (i: { input: string; steps: AgentStep[] }) => formatAgentSteps(i.steps),
+            [memoryKey]: async (_: { input: string; steps: AgentStep[] }) => {
+                const messages = (await memory.getChatMessages(flowObj?.sessionId, true, chatHistory)) as BaseMessage[]
+                return messages ?? []
+            }
+        },
+        prompt,
+        modelWithFunctions,
+        new OpenAIFunctionsAgentOutputParser()
+    ])
+
+    const executor = AgentExecutor.fromAgentAndTools({
+        agent: runnableAgent,
+        tools,
+        sessionId: flowObj?.sessionId,
+        chatId: flowObj?.chatId,
+        input: flowObj?.input,
+        returnIntermediateSteps: true,
+        verbose: process.env.DEBUG === 'true' ? true : false
+    })
+
+    return executor
+}
+
 module.exports = { nodeClass: ConversationalRetrievalAgent_Agents }

packages/components/nodes/agents/OpenAIAssistant/OpenAIAssistant.ts

@@ -96,45 +96,51 @@ class OpenAIAssistant_Agents implements INode {
         return null
     }
 
-    //@ts-ignore
-    memoryMethods = {
-        async clearSessionMemory(nodeData: INodeData, options: ICommonObject): Promise<void> {
-            const selectedAssistantId = nodeData.inputs?.selectedAssistant as string
-            const appDataSource = options.appDataSource as DataSource
-            const databaseEntities = options.databaseEntities as IDatabaseEntity
-            let sessionId = nodeData.inputs?.sessionId as string
+    async clearChatMessages(nodeData: INodeData, options: ICommonObject, sessionIdObj: { type: string; id: string }): Promise<void> {
+        const selectedAssistantId = nodeData.inputs?.selectedAssistant as string
+        const appDataSource = options.appDataSource as DataSource
+        const databaseEntities = options.databaseEntities as IDatabaseEntity
 
-            const assistant = await appDataSource.getRepository(databaseEntities['Assistant']).findOneBy({
-                id: selectedAssistantId
+        const assistant = await appDataSource.getRepository(databaseEntities['Assistant']).findOneBy({
+            id: selectedAssistantId
+        })
+
+        if (!assistant) {
+            options.logger.error(`Assistant ${selectedAssistantId} not found`)
+            return
+        }
+
+        if (!sessionIdObj) return
+
+        let sessionId = ''
+        if (sessionIdObj.type === 'chatId') {
+            const chatId = sessionIdObj.id
+            const chatmsg = await appDataSource.getRepository(databaseEntities['ChatMessage']).findOneBy({
+                chatId
             })
-
-            if (!assistant) {
-                options.logger.error(`Assistant ${selectedAssistantId} not found`)
+            if (!chatmsg) {
+                options.logger.error(`Chat Message with Chat Id: ${chatId} not found`)
                 return
             }
+            sessionId = chatmsg.sessionId
+        } else if (sessionIdObj.type === 'threadId') {
+            sessionId = sessionIdObj.id
+        }
 
-            if (!sessionId && options.chatId) {
-                const chatmsg = await appDataSource.getRepository(databaseEntities['ChatMessage']).findOneBy({
-                    chatId: options.chatId
-                })
-                if (!chatmsg) {
-                    options.logger.error(`Chat Message with Chat Id: ${options.chatId} not found`)
-                    return
-                }
-                sessionId = chatmsg.sessionId
-            }
+        const credentialData = await getCredentialData(assistant.credential ?? '', options)
+        const openAIApiKey = getCredentialParam('openAIApiKey', credentialData, nodeData)
+        if (!openAIApiKey) {
+            options.logger.error(`OpenAI ApiKey not found`)
+            return
+        }
 
-            const credentialData = await getCredentialData(assistant.credential ?? '', options)
-            const openAIApiKey = getCredentialParam('openAIApiKey', credentialData, nodeData)
-            if (!openAIApiKey) {
-                options.logger.error(`OpenAI ApiKey not found`)
-                return
-            }
-
-            const openai = new OpenAI({ apiKey: openAIApiKey })
-            options.logger.info(`Clearing OpenAI Thread ${sessionId}`)
+        const openai = new OpenAI({ apiKey: openAIApiKey })
+        options.logger.info(`Clearing OpenAI Thread ${sessionId}`)
+        try {
             if (sessionId) await openai.beta.threads.del(sessionId)
             options.logger.info(`Successfully cleared OpenAI Thread ${sessionId}`)
+        } catch (e) {
+            throw new Error(e)
         }
     }
 
@@ -297,7 +303,11 @@ class OpenAIAssistant_Agents implements INode {
                                         options.socketIO.to(options.socketIOClientId).emit('tool', tool.name)
 
                                     try {
-                                        const toolOutput = await tool.call(actions[i].toolInput, undefined, undefined, threadId)
+                                        const toolOutput = await tool.call(actions[i].toolInput, undefined, undefined, {
+                                            sessionId: threadId,
+                                            chatId: options.chatId,
+                                            input
+                                        })
                                         await analyticHandlers.onToolEnd(toolIds, toolOutput)
                                         submitToolOutputs.push({
                                             tool_call_id: actions[i].toolCallId,
@@ -462,6 +472,7 @@ class OpenAIAssistant_Agents implements INode {
             const imageRegex = /<img[^>]*\/>/g
             let llmOutput = returnVal.replace(imageRegex, '')
             llmOutput = llmOutput.replace('<br/>', '')
+
             await analyticHandlers.onLLMEnd(llmIds, llmOutput)
             await analyticHandlers.onChainEnd(parentIds, messageData, true)
 

packages/components/nodes/agents/OpenAIFunctionAgent/OpenAIFunctionAgent.ts

@@ -1,17 +1,14 @@
-import { FlowiseMemory, ICommonObject, INode, INodeData, INodeParams } from '../../../src/Interface'
-import { AgentExecutor as LCAgentExecutor, AgentExecutorInput } from 'langchain/agents'
-import { ChainValues, AgentStep, AgentFinish, AgentAction, BaseMessage, FunctionMessage, AIMessage } from 'langchain/schema'
-import { OutputParserException } from 'langchain/schema/output_parser'
-import { CallbackManagerForChainRun } from 'langchain/callbacks'
-import { formatToOpenAIFunction } from 'langchain/tools'
-import { ToolInputParsingException, Tool } from '@langchain/core/tools'
+import { ChainValues, AgentStep, BaseMessage } from 'langchain/schema'
 import { getBaseClasses } from '../../../src/utils'
 import { flatten } from 'lodash'
 import { RunnableSequence } from 'langchain/schema/runnable'
+import { formatToOpenAIFunction } from 'langchain/tools'
+import { ChatOpenAI } from 'langchain/chat_models/openai'
+import { FlowiseMemory, ICommonObject, IMessage, INode, INodeData, INodeParams } from '../../../src/Interface'
 import { ConsoleCallbackHandler, CustomChainHandler, additionalCallbacks } from '../../../src/handler'
 import { ChatPromptTemplate, MessagesPlaceholder } from 'langchain/prompts'
-import { ChatOpenAI } from 'langchain/chat_models/openai'
 import { OpenAIFunctionsAgentOutputParser } from 'langchain/agents/openai/output_parser'
+import { AgentExecutor, formatAgentSteps } from '../../../src/agents'
 
 class OpenAIFunctionAgent_Agents implements INode {
     label: string
@@ -25,7 +22,7 @@ class OpenAIFunctionAgent_Agents implements INode {
     inputs: INodeParams[]
     sessionId?: string
 
-    constructor(fields: { sessionId?: string }) {
+    constructor(fields?: { sessionId?: string }) {
         this.label = 'OpenAI Function Agent'
         this.name = 'openAIFunctionAgent'
         this.version = 3.0
@@ -33,7 +30,7 @@ class OpenAIFunctionAgent_Agents implements INode {
         this.category = 'Agents'
         this.icon = 'function.svg'
         this.description = `An agent that uses Function Calling to pick the tool and args to call`
-        this.baseClasses = [this.type, ...getBaseClasses(LCAgentExecutor)]
+        this.baseClasses = [this.type, ...getBaseClasses(AgentExecutor)]
         this.inputs = [
             {
                 label: 'Allowed Tools',
@@ -63,19 +60,13 @@ class OpenAIFunctionAgent_Agents implements INode {
         this.sessionId = fields?.sessionId
     }
 
-    async init(nodeData: INodeData): Promise<any> {
-        const memory = nodeData.inputs?.memory as FlowiseMemory
-
-        const executor = prepareAgent(nodeData, this.sessionId)
-        if (memory) executor.memory = memory
-
-        return executor
+    async init(nodeData: INodeData, input: string, options: ICommonObject): Promise<any> {
+        return prepareAgent(nodeData, { sessionId: this.sessionId, chatId: options.chatId, input }, options.chatHistory)
     }
 
     async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<string> {
         const memory = nodeData.inputs?.memory as FlowiseMemory
-
-        const executor = prepareAgent(nodeData, this.sessionId)
+        const executor = prepareAgent(nodeData, { sessionId: this.sessionId, chatId: options.chatId, input }, options.chatHistory)
 
         const loggerHandler = new ConsoleCallbackHandler(options.logger)
         const callbacks = await additionalCallbacks(nodeData, options)
@@ -107,17 +98,11 @@ class OpenAIFunctionAgent_Agents implements INode {
     }
 }
 
-const formatAgentSteps = (steps: AgentStep[]): BaseMessage[] =>
-    steps.flatMap(({ action, observation }) => {
-        if ('messageLog' in action && action.messageLog !== undefined) {
-            const log = action.messageLog as BaseMessage[]
-            return log.concat(new FunctionMessage(observation, action.tool))
-        } else {
-            return [new AIMessage(action.log)]
-        }
-    })
-
-const prepareAgent = (nodeData: INodeData, sessionId?: string) => {
+const prepareAgent = (
+    nodeData: INodeData,
+    flowObj: { sessionId?: string; chatId?: string; input?: string },
+    chatHistory: IMessage[] = []
+) => {
     const model = nodeData.inputs?.model as ChatOpenAI
     const memory = nodeData.inputs?.memory as FlowiseMemory
     const systemMessage = nodeData.inputs?.systemMessage as string
@@ -142,7 +127,7 @@ const prepareAgent = (nodeData: INodeData, sessionId?: string) => {
             [inputKey]: (i: { input: string; steps: AgentStep[] }) => i.input,
             agent_scratchpad: (i: { input: string; steps: AgentStep[] }) => formatAgentSteps(i.steps),
             [memoryKey]: async (_: { input: string; steps: AgentStep[] }) => {
-                const messages = (await memory.getChatMessages(sessionId, true)) as BaseMessage[]
+                const messages = (await memory.getChatMessages(flowObj?.sessionId, true, chatHistory)) as BaseMessage[]
                 return messages ?? []
             }
         },
@@ -154,231 +139,13 @@ const prepareAgent = (nodeData: INodeData, sessionId?: string) => {
     const executor = AgentExecutor.fromAgentAndTools({
         agent: runnableAgent,
         tools,
-        sessionId
+        sessionId: flowObj?.sessionId,
+        chatId: flowObj?.chatId,
+        input: flowObj?.input,
+        verbose: process.env.DEBUG === 'true' ? true : false
     })
 
     return executor
 }
 
-type AgentExecutorOutput = ChainValues
-
-class AgentExecutor extends LCAgentExecutor {
-    sessionId?: string
-
-    static fromAgentAndTools(fields: AgentExecutorInput & { sessionId?: string }): AgentExecutor {
-        const newInstance = new AgentExecutor(fields)
-        if (fields.sessionId) newInstance.sessionId = fields.sessionId
-        return newInstance
-    }
-
-    shouldContinueIteration(iterations: number): boolean {
-        return this.maxIterations === undefined || iterations < this.maxIterations
-    }
-
-    async _call(inputs: ChainValues, runManager?: CallbackManagerForChainRun): Promise<AgentExecutorOutput> {
-        const toolsByName = Object.fromEntries(this.tools.map((t) => [t.name.toLowerCase(), t]))
-
-        const steps: AgentStep[] = []
-        let iterations = 0
-
-        const getOutput = async (finishStep: AgentFinish): Promise<AgentExecutorOutput> => {
-            const { returnValues } = finishStep
-            const additional = await this.agent.prepareForOutput(returnValues, steps)
-
-            if (this.returnIntermediateSteps) {
-                return { ...returnValues, intermediateSteps: steps, ...additional }
-            }
-            await runManager?.handleAgentEnd(finishStep)
-            return { ...returnValues, ...additional }
-        }
-
-        while (this.shouldContinueIteration(iterations)) {
-            let output
-            try {
-                output = await this.agent.plan(steps, inputs, runManager?.getChild())
-            } catch (e) {
-                if (e instanceof OutputParserException) {
-                    let observation
-                    let text = e.message
-                    if (this.handleParsingErrors === true) {
-                        if (e.sendToLLM) {
-                            observation = e.observation
-                            text = e.llmOutput ?? ''
-                        } else {
-                            observation = 'Invalid or incomplete response'
-                        }
-                    } else if (typeof this.handleParsingErrors === 'string') {
-                        observation = this.handleParsingErrors
-                    } else if (typeof this.handleParsingErrors === 'function') {
-                        observation = this.handleParsingErrors(e)
-                    } else {
-                        throw e
-                    }
-                    output = {
-                        tool: '_Exception',
-                        toolInput: observation,
-                        log: text
-                    } as AgentAction
-                } else {
-                    throw e
-                }
-            }
-            // Check if the agent has finished
-            if ('returnValues' in output) {
-                return getOutput(output)
-            }
-
-            let actions: AgentAction[]
-            if (Array.isArray(output)) {
-                actions = output as AgentAction[]
-            } else {
-                actions = [output as AgentAction]
-            }
-
-            const newSteps = await Promise.all(
-                actions.map(async (action) => {
-                    await runManager?.handleAgentAction(action)
-                    const tool = action.tool === '_Exception' ? new ExceptionTool() : toolsByName[action.tool?.toLowerCase()]
-                    let observation
-                    try {
-                        // here we need to override Tool call method to include sessionId as parameter
-                        observation = tool
-                            ? // @ts-ignore
-                              await tool.call(action.toolInput, runManager?.getChild(), undefined, this.sessionId)
-                            : `${action.tool} is not a valid tool, try another one.`
-                    } catch (e) {
-                        if (e instanceof ToolInputParsingException) {
-                            if (this.handleParsingErrors === true) {
-                                observation = 'Invalid or incomplete tool input. Please try again.'
-                            } else if (typeof this.handleParsingErrors === 'string') {
-                                observation = this.handleParsingErrors
-                            } else if (typeof this.handleParsingErrors === 'function') {
-                                observation = this.handleParsingErrors(e)
-                            } else {
-                                throw e
-                            }
-                            observation = await new ExceptionTool().call(observation, runManager?.getChild())
-                            return { action, observation: observation ?? '' }
-                        }
-                    }
-                    return { action, observation: observation ?? '' }
-                })
-            )
-
-            steps.push(...newSteps)
-
-            const lastStep = steps[steps.length - 1]
-            const lastTool = toolsByName[lastStep.action.tool?.toLowerCase()]
-
-            if (lastTool?.returnDirect) {
-                return getOutput({
-                    returnValues: { [this.agent.returnValues[0]]: lastStep.observation },
-                    log: ''
-                })
-            }
-
-            iterations += 1
-        }
-
-        const finish = await this.agent.returnStoppedResponse(this.earlyStoppingMethod, steps, inputs)
-
-        return getOutput(finish)
-    }
-
-    async _takeNextStep(
-        nameToolMap: Record<string, Tool>,
-        inputs: ChainValues,
-        intermediateSteps: AgentStep[],
-        runManager?: CallbackManagerForChainRun
-    ): Promise<AgentFinish | AgentStep[]> {
-        let output
-        try {
-            output = await this.agent.plan(intermediateSteps, inputs, runManager?.getChild())
-        } catch (e) {
-            if (e instanceof OutputParserException) {
-                let observation
-                let text = e.message
-                if (this.handleParsingErrors === true) {
-                    if (e.sendToLLM) {
-                        observation = e.observation
-                        text = e.llmOutput ?? ''
-                    } else {
-                        observation = 'Invalid or incomplete response'
-                    }
-                } else if (typeof this.handleParsingErrors === 'string') {
-                    observation = this.handleParsingErrors
-                } else if (typeof this.handleParsingErrors === 'function') {
-                    observation = this.handleParsingErrors(e)
-                } else {
-                    throw e
-                }
-                output = {
-                    tool: '_Exception',
-                    toolInput: observation,
-                    log: text
-                } as AgentAction
-            } else {
-                throw e
-            }
-        }
-
-        if ('returnValues' in output) {
-            return output
-        }
-
-        let actions: AgentAction[]
-        if (Array.isArray(output)) {
-            actions = output as AgentAction[]
-        } else {
-            actions = [output as AgentAction]
-        }
-
-        const result: AgentStep[] = []
-        for (const agentAction of actions) {
-            let observation = ''
-            if (runManager) {
-                await runManager?.handleAgentAction(agentAction)
-            }
-            if (agentAction.tool in nameToolMap) {
-                const tool = nameToolMap[agentAction.tool]
-                try {
-                    // here we need to override Tool call method to include sessionId as parameter
-                    // @ts-ignore
-                    observation = await tool.call(agentAction.toolInput, runManager?.getChild(), undefined, this.sessionId)
-                } catch (e) {
-                    if (e instanceof ToolInputParsingException) {
-                        if (this.handleParsingErrors === true) {
-                            observation = 'Invalid or incomplete tool input. Please try again.'
-                        } else if (typeof this.handleParsingErrors === 'string') {
-                            observation = this.handleParsingErrors
-                        } else if (typeof this.handleParsingErrors === 'function') {
-                            observation = this.handleParsingErrors(e)
-                        } else {
-                            throw e
-                        }
-                        observation = await new ExceptionTool().call(observation, runManager?.getChild())
-                    }
-                }
-            } else {
-                observation = `${agentAction.tool} is not a valid tool, try another available tool: ${Object.keys(nameToolMap).join(', ')}`
-            }
-            result.push({
-                action: agentAction,
-                observation
-            })
-        }
-        return result
-    }
-}
-
-class ExceptionTool extends Tool {
-    name = '_Exception'
-
-    description = 'Exception tool'
-
-    async _call(query: string) {
-        return query
-    }
-}
-
 module.exports = { nodeClass: OpenAIFunctionAgent_Agents }