@botonic/plugin-flow-builder 0.26.1 → 0.27.0-alpha.0

package/src/action/index.tsx

@@ -5,8 +5,9 @@ import { FlowBuilderApi } from '../api'
 import { FlowContent, FlowHandoff } from '../content-fields'
 import { HtNodeWithContent } from '../content-fields/hubtype-fields'
 import { getFlowBuilderPlugin } from '../helpers'
+import BotonicPluginFlowBuilder from '../index'
+import { EventAction, getNodeEventArgs, trackEvent } from '../tracking'
 import { createNodeFromKnowledgeBase } from './knowledge-bases'
-import { EventName, trackEvent } from '../tracking'
 
 export type FlowBuilderActionProps = {
   contents: FlowContent[]
@@ -18,15 +19,7 @@ export class FlowBuilderAction extends React.Component<FlowBuilderActionProps> {
   static async botonicInit(
     request: ActionRequest
   ): Promise<FlowBuilderActionProps> {
-    const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-    const locale = flowBuilderPlugin.getLocale(request.session)
-
-    const targetNode = await getTargetNode(flowBuilderPlugin.cmsApi, request)
-
-    const contents = await flowBuilderPlugin.getContentsByNode(
-      targetNode,
-      locale
-    )
+    const contents = await getContents(request)
 
     const handoffContent = contents.find(
       content => content instanceof FlowHandoff
@@ -55,26 +48,64 @@ export class FlowBuilderMultichannelAction extends FlowBuilderAction {
   }
 }
 
-async function getTargetNode(cmsApi: FlowBuilderApi, request: ActionRequest) {
+async function getContents(request: ActionRequest): Promise<FlowContent[]> {
+  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
+  const cmsApi = flowBuilderPlugin.cmsApi
+  const locale = flowBuilderPlugin.getLocale(request.session)
+  const resolvedLocale = flowBuilderPlugin.cmsApi.getResolvedLocale(locale)
+  const context = {
+    cmsApi,
+    flowBuilderPlugin,
+    request,
+    resolvedLocale,
+  }
+
   if (request.session.is_first_interaction) {
-    const startNode = cmsApi.getStartNode()
-    await trackEvent(request, EventName.botStart)
-    return startNode
+    return await flowBuilderPlugin.getStartContents(resolvedLocale)
+  }
+
+  if (request.input.payload) {
+    return await getContentsByPayload(context)
   }
-  const contentId = request.input.payload
 
-  const targetNode = contentId
-    ? cmsApi.getNodeById<HtNodeWithContent>(contentId)
+  return await getContentsByFallback(context)
+}
+
+interface FlowBuilderContext {
+  cmsApi: FlowBuilderApi
+  flowBuilderPlugin: BotonicPluginFlowBuilder
+  request: ActionRequest
+  resolvedLocale: string
+}
+
+async function getContentsByPayload({
+  cmsApi,
+  flowBuilderPlugin,
+  request,
+  resolvedLocale,
+}: FlowBuilderContext): Promise<FlowContent[]> {
+  const targetNode = request.input.payload
+    ? cmsApi.getNodeById<HtNodeWithContent>(request.input.payload)
     : undefined
 
   if (targetNode) {
-    const eventArgs = {
-      faq_name: targetNode.code,
-    }
-    await trackEvent(request, EventName.botFaq, eventArgs)
-    return targetNode
+    const eventArgs = getNodeEventArgs(request, targetNode)
+    await trackEvent(request, EventAction.flowNode, eventArgs)
+    return await flowBuilderPlugin.getContentsByNode(targetNode, resolvedLocale)
   }
-  return await getFallbackNode(cmsApi, request)
+  return []
+}
+
+async function getContentsByFallback({
+  cmsApi,
+  flowBuilderPlugin,
+  request,
+  resolvedLocale,
+}: FlowBuilderContext): Promise<FlowContent[]> {
+  const fallbackNode = await getFallbackNode(cmsApi, request)
+  const eventArgs = getNodeEventArgs(request, fallbackNode)
+  await trackEvent(request, EventAction.flowNode, eventArgs)
+  return await flowBuilderPlugin.getContentsByNode(fallbackNode, resolvedLocale)
 }
 
 async function getFallbackNode(cmsApi: FlowBuilderApi, request: ActionRequest) {
@@ -95,6 +126,9 @@ async function getFallbackNode(cmsApi: FlowBuilderApi, request: ActionRequest) {
   const fallbackNode = cmsApi.getFallbackNode(isFirstFallbackOption)
   request.session.user.extra_data.isFirstFallbackOption = !isFirstFallbackOption
 
-  await trackEvent(request, EventName.fallback)
+  trackEvent(request, EventAction.fallback, {
+    fallbackAttempt: isFirstFallbackOption ? 1 : 2,
+  })
+
   return fallbackNode
 }

package/src/action/knowledge-bases.ts

@@ -9,7 +9,7 @@ import {
   HtTextNode,
 } from '../content-fields/hubtype-fields'
 import { getFlowBuilderPlugin } from '../helpers'
-import { EventName, trackEvent } from '../tracking'
+import { EventAction, trackEvent } from '../tracking'
 
 export async function createNodeFromKnowledgeBase(
   cmsApi: FlowBuilderApi,
@@ -28,11 +28,11 @@ export async function createNodeFromKnowledgeBase(
       const knowledgeBaseResponse =
         await flowBuilderPlugin.getKnowledgeBaseResponse(request)
       if (knowledgeBaseResponse.hasKnowledge) {
-        await trackEvent(request, EventName.botAiKnowledgeBase, {
-          answer: knowledgeBaseResponse.answer,
-          knowledge_source_ids: knowledgeBaseResponse.sources.map(
+        await trackEvent(request, EventAction.knowledgebase, {
+          knowledgebaseSourcesIds: knowledgeBaseResponse.sources.map(
             source => source.knowledgeSourceId
           ),
+          knowledgebaseChunksIds: [],
         })
 
         const knowledgeBaseNode: HtTextNode = {
@@ -58,8 +58,19 @@ export async function createNodeFromKnowledgeBase(
         }
         return knowledgeBaseNode
       }
+      await trackEvent(request, EventAction.knowledgebase, {
+        knowledgebaseFailReason:
+          'The knowledge base does not have enough knowledge',
+        knowledgeSourceIds: [],
+        knowledgebaseChunksIds: [],
+      })
     } catch (e) {
-      console.log('Hubtype knowledge base api error: ', { e })
+      console.error('Hubtype knowledge base api error: ', { e })
+      await trackEvent(request, EventAction.knowledgebase, {
+        knowledgebaseFailReason: 'Knowledge base api error',
+        knowledgeSourceIds: [],
+        knowledgebaseChunksIds: [],
+      })
       return undefined
     }
   }

package/src/api.ts

@@ -1,7 +1,7 @@
 import { Input, PluginPreRequest } from '@botonic/core'
 import axios from 'axios'
 
-import { REG_EXP_PATTERN, SEPARATOR } from './constants'
+import { BOT_ACTION_PAYLOAD_PREFIX, SEPARATOR } from './constants'
 import {
   HtBotActionNode,
   HtFallbackNode,
@@ -150,57 +150,10 @@ export class FlowBuilderApi {
     return predictedConfidence >= nodeConfidence
   }
 
-  getNodeByKeyword(
-    userInput: string,
-    locale: string
-  ): HtKeywordNode | undefined {
-    try {
-      const keywordNodes = this.flow.nodes.filter(
-        node => node.type === HtNodeWithContentType.KEYWORD
-      ) as HtKeywordNode[]
-      const matchedKeywordNodes = keywordNodes.filter(node =>
-        this.matchKeywords(node, userInput, locale)
-      )
-      if (matchedKeywordNodes.length > 0 && matchedKeywordNodes[0].target) {
-        return matchedKeywordNodes[0]
-      }
-    } catch (error) {
-      console.error(`Error getting node by keyword '${userInput}': `, error)
-    }
-
-    return undefined
-  }
-
-  private matchKeywords(
-    node: HtKeywordNode,
-    input: string,
-    locale: string
-  ): boolean {
-    const result = node.content.keywords.find(
-      keywords =>
-        keywords.locale === locale &&
-        this.inputMatchesAnyKeyword(input, keywords.values)
-    )
-    return Boolean(result)
-  }
-
-  private inputMatchesAnyKeyword(input: string, keywords: string[]): boolean {
-    return keywords.some(keyword => {
-      const regExpMatchArray = keyword.match(REG_EXP_PATTERN)
-      if (regExpMatchArray) {
-        return this.resolveKeywordAsRegExp(regExpMatchArray, input)
-      }
-      return input.includes(keyword)
-    })
-  }
-
-  private resolveKeywordAsRegExp(
-    regExpMatchArray: RegExpMatchArray,
-    input: string
-  ) {
-    const [, pattern, flags] = regExpMatchArray
-    const keywordAsRegExp = new RegExp(pattern, flags)
-    return input.match(keywordAsRegExp)
+  getKeywordNodes(): HtKeywordNode[] {
+    return this.flow.nodes.filter(
+      node => node.type === HtNodeWithContentType.KEYWORD
+    ) as HtKeywordNode[]
   }
 
   getPayload(target?: HtNodeLink): string | undefined {
@@ -209,14 +162,13 @@ export class FlowBuilderApi {
     }
 
     if (target.type === HtNodeWithoutContentType.BOT_ACTION) {
-      const botActionNode = this.getNodeById<HtBotActionNode>(target.id)
-      return this.createPayloadWithParams(botActionNode)
+      return `${BOT_ACTION_PAYLOAD_PREFIX}${target.id}`
     }
 
     return target.id
   }
 
-  private createPayloadWithParams(botActionNode: HtBotActionNode): string {
+  createPayloadWithParams(botActionNode: HtBotActionNode): string {
     const payloadId = botActionNode.content.payload_id
     const payloadNode = this.getNodeById<HtPayloadNode>(payloadId)
     const customParams = JSON.parse(
@@ -247,6 +199,11 @@ export class FlowBuilderApi {
     }
   }
 
+  getFlowName(flowId: string): string {
+    const flow = this.flow.flows.find(flow => flow.id === flowId)
+    return flow ? flow.name : ''
+  }
+
   getResolvedLocale(locale: string): string {
     if (this.flow.locales.find(flowLocale => flowLocale === locale)) {
       return locale

package/src/constants.ts

@@ -2,6 +2,7 @@ export const FLOW_BUILDER_API_URL_PROD =
   'https://api.ent0.flowbuilder.prod.hubtype.com'
 export const SEPARATOR = '|'
 export const SOURCE_INFO_SEPARATOR = `${SEPARATOR}source_`
+export const BOT_ACTION_PAYLOAD_PREFIX = `ba${SEPARATOR}`
 export const VARIABLE_PATTERN = /{([^}]+)}/g
 export const ACCESS_TOKEN_VARIABLE_KEY = '_access_token'
 export const REG_EXP_PATTERN = /^\/(.*)\/([gimyus]*)$/

package/src/content-fields/flow-button.tsx

@@ -21,7 +21,6 @@ export class FlowButton extends ContentFieldsBase {
     locale: string,
     cmsApi: FlowBuilderApi
   ): FlowButton {
-    const payloadId = this.getPayloadId(cmsButton, locale)
     const urlId = this.getUrlId(cmsButton, locale)
 
     const newButton = new FlowButton(cmsButton.id)
@@ -30,11 +29,6 @@ export class FlowButton extends ContentFieldsBase {
       newButton.payload = cmsApi.getPayload(cmsButton.target)
     }
 
-    // OLD PAYLOAD
-    if (cmsButton.payload && payloadId) {
-      const payloadNode = cmsApi.getNodeById<HtPayloadNode>(payloadId)
-      newButton.payload = payloadNode.content.payload
-    }
     if (cmsButton.url && urlId) {
       const urlNode = cmsApi.getNodeById<HtUrlNode>(urlId)
       newButton.url = urlNode.content.url
@@ -43,10 +37,6 @@ export class FlowButton extends ContentFieldsBase {
     return newButton
   }
 
-  static getPayloadId(cmsButton: HtButton, locale: string): string | undefined {
-    return cmsButton.payload.find(payload => payload.locale === locale)?.id
-  }
-
   static getUrlId(cmsButton: HtButton, locale: string): string | undefined {
     return cmsButton.url.find(url => url.locale === locale)?.id
   }

package/src/content-fields/flow-handoff.tsx

@@ -2,11 +2,9 @@ import { HandOffBuilder } from '@botonic/core'
 import { ActionRequest, WebchatSettings } from '@botonic/react'
 import React from 'react'
 
-import { EventName, trackEvent } from '../tracking'
 import { FlowBuilderApi } from '../api'
-import { getQueueAvailability } from '../functions/conditional-queue-status'
 import { ContentFieldsBase } from './content-fields-base'
-import { HtHandoffNode, HtPayloadNode, HtQueueLocale } from './hubtype-fields'
+import { HtHandoffNode, HtQueueLocale } from './hubtype-fields'
 
 export class FlowHandoff extends ContentFieldsBase {
   public code: string
@@ -22,11 +20,7 @@ export class FlowHandoff extends ContentFieldsBase {
     const newHandoff = new FlowHandoff(cmsHandoff.id)
     newHandoff.code = cmsHandoff.code
     newHandoff.queue = this.getQueueByLocale(locale, cmsHandoff.content.queue)
-    newHandoff.onFinishPayload = this.getOnFinishPayload(
-      cmsHandoff,
-      locale,
-      cmsApi
-    )
+    newHandoff.onFinishPayload = this.getOnFinishPayload(cmsHandoff, cmsApi)
     newHandoff.handoffAutoAssign = cmsHandoff.content.has_auto_assign
 
     return newHandoff
@@ -34,43 +28,29 @@ export class FlowHandoff extends ContentFieldsBase {
 
   private static getOnFinishPayload(
     cmsHandoff: HtHandoffNode,
-    locale: string,
     cmsApi: FlowBuilderApi
   ): string | undefined {
     if (cmsHandoff.target?.id) {
       return cmsApi.getPayload(cmsHandoff.target)
     }
 
-    // OLD PAYLOAD
-    const payloadId = cmsHandoff.content.payload.find(
-      payload => payload.locale === locale
-    )?.id
-    if (payloadId) {
-      return cmsApi.getNodeById<HtPayloadNode>(payloadId).content.payload
-    }
-
     return undefined
   }
 
   async doHandoff(request: ActionRequest): Promise<void> {
-    // @ts-ignore
     const handOffBuilder = new HandOffBuilder(request.session)
     handOffBuilder.withAutoAssignOnWaiting(this.handoffAutoAssign)
+
     if (this.onFinishPayload) {
       handOffBuilder.withOnFinishPayload(this.onFinishPayload)
     }
-    if (this.queue) {
-      const availabilityData = await getQueueAvailability(this.queue.id)
-      const eventArgs = {
-        queue_open: availabilityData.open,
-        queue_id: this.queue.id,
-        available_agents: availabilityData.available_agents > 0,
-        threshold_reached:
-          availabilityData.availability_threshold_waiting_cases > 0,
-      }
-      await trackEvent(request, EventName.handoffSuccess, eventArgs)
 
+    if (this.queue) {
       handOffBuilder.withQueue(this.queue.id)
+      handOffBuilder.withBotEvent({
+        language: request.session.user.extra_data.language,
+        country: request.session.user.extra_data.country,
+      })
       await handOffBuilder.handOff()
     }
   }

package/src/content-fields/hubtype-fields/button.ts

@@ -1,15 +1,9 @@
-import {
-  HtNodeLink,
-  HtPayloadLocale,
-  HtTextLocale,
-  HtUrlLocale,
-} from './common'
+import { HtNodeLink, HtTextLocale, HtUrlLocale } from './common'
 
 export interface HtButton {
   id: string
   text: HtTextLocale[]
   url: HtUrlLocale[]
-  payload: HtPayloadLocale[]
   target?: HtNodeLink
   hidden: string[]
 }

package/src/content-fields/index.ts

@@ -11,6 +11,7 @@ export { FlowButton } from './flow-button'
 export { FlowElement } from './flow-element'
 export { FlowCarousel, FlowImage, FlowText, FlowVideo, FlowWhatsappButtonList }
 export { FlowHandoff } from './flow-handoff'
+export { FlowWhatsappCtaUrlButtonNode } from './flow-whatsapp-cta-url-button'
 
 export type FlowContent =
   | FlowCarousel

package/src/functions/conditional-queue-status.ts

@@ -1,6 +1,8 @@
 import { ActionRequest } from '@botonic/react'
 import axios from 'axios'
 
+// import { EventAction, trackEvent } from '../tracking'
+
 const HUBTYPE_API_URL = process.env.HUBTYPE_API_URL || 'https://api.hubtype.com'
 
 type ConditionalQueueStatusArgs = {
@@ -17,17 +19,48 @@ enum QueueStatusResult {
 }
 
 export async function conditionalQueueStatus({
+  // request,
   queue_id,
+  // queue_name,
   check_available_agents,
 }: ConditionalQueueStatusArgs): Promise<QueueStatusResult> {
   const data = await getQueueAvailability(queue_id, check_available_agents)
+  // await trackEvent(request, EventAction.handoffOption, {
+  //   queueId: queue_id,
+  //   queueName: queue_name,
+  // })
   if (check_available_agents && data.open && data.available_agents === 0) {
     return QueueStatusResult.OPEN_WITHOUT_AGENTS
   }
   return data.open ? QueueStatusResult.OPEN : QueueStatusResult.CLOSED
 }
 
-interface AvailabilityData {
+export class HubtypeQueuesApi {
+  public queueId: string
+  public checkAvailableAgents: boolean
+
+  constructor(queueId: string, checkAvailableAgents?: boolean) {
+    this.queueId = queueId
+    this.checkAvailableAgents = checkAvailableAgents || false
+  }
+
+  async getAvailability(): Promise<AvailabilityData> {
+    const response = await axios.get(
+      `${HUBTYPE_API_URL}/public/v1/queues/${this.queueId}/availability/`,
+      // TODO: Make it configurable in the future
+      {
+        params: {
+          check_queue_schedule: true,
+          check_waiting_cases: false,
+          check_available_agents: this.checkAvailableAgents,
+        },
+      }
+    )
+    return response.data
+  }
+}
+
+export interface AvailabilityData {
   available: boolean
   waiting_cases: number
   availability_threshold_waiting_cases: number
@@ -40,16 +73,6 @@ export async function getQueueAvailability(
   queueId: string,
   checkAvailableAgents = false
 ): Promise<AvailabilityData> {
-  const response = await axios.get(
-    `${HUBTYPE_API_URL}/public/v1/queues/${queueId}/availability/`,
-    // TODO: Make it configurable in the future
-    {
-      params: {
-        check_queue_schedule: true,
-        check_waiting_cases: false,
-        check_available_agents: checkAvailableAgents,
-      },
-    }
-  )
-  return response.data
+  const queuesApi = new HubtypeQueuesApi(queueId, checkAvailableAgents)
+  return await queuesApi.getAvailability()
 }

package/src/index.ts

@@ -1,8 +1,10 @@
 import { Plugin, PluginPreRequest, Session } from '@botonic/core'
 import { ActionRequest } from '@botonic/react'
+import { v4 as uuid } from 'uuid'
 
 import { FlowBuilderApi } from './api'
 import {
+  BOT_ACTION_PAYLOAD_PREFIX,
   FLOW_BUILDER_API_URL_PROD,
   SEPARATOR,
   SOURCE_INFO_SEPARATOR,
@@ -18,6 +20,7 @@ import {
 } from './content-fields'
 import { FlowWhatsappCtaUrlButtonNode } from './content-fields/flow-whatsapp-cta-url-button'
 import {
+  HtBotActionNode,
   HtFlowBuilderData,
   HtFunctionArgument,
   HtFunctionArguments,
@@ -27,6 +30,7 @@ import {
   HtNodeWithContentType,
 } from './content-fields/hubtype-fields'
 import { DEFAULT_FUNCTIONS } from './functions'
+import { EventAction, getNodeEventArgs, trackEvent } from './tracking'
 import {
   BotonicPluginFlowBuilderOptions,
   FlowBuilderJSONVersion,
@@ -34,8 +38,8 @@ import {
   PayloadParamsBase,
 } from './types'
 import { getNodeByUserInput } from './user-input'
+import { SmartIntentsInferenceConfig } from './user-input/smart-intent'
 import { resolveGetAccessToken } from './utils'
-
 export default class BotonicPluginFlowBuilder implements Plugin {
   public cmsApi: FlowBuilderApi
   private flowUrl: string
@@ -46,12 +50,13 @@ export default class BotonicPluginFlowBuilder implements Plugin {
   public getLocale: (session: Session) => string
   public trackEvent?: (
     request: ActionRequest,
-    eventName: string,
+    eventAction: string,
     args?: Record<string, any>
   ) => Promise<void>
   public getKnowledgeBaseResponse?: (
     request: ActionRequest
   ) => Promise<KnowledgeBaseResponse>
+  public smartIntentsConfig: SmartIntentsInferenceConfig
 
   constructor(readonly options: BotonicPluginFlowBuilderOptions) {
     const apiUrl = options.apiUrl || FLOW_BUILDER_API_URL_PROD
@@ -62,6 +67,10 @@ export default class BotonicPluginFlowBuilder implements Plugin {
     this.getAccessToken = resolveGetAccessToken(options)
     this.trackEvent = options.trackEvent
     this.getKnowledgeBaseResponse = options.getKnowledgeBaseResponse
+    this.smartIntentsConfig = {
+      ...options?.smartIntentsConfig,
+      useLatest: jsonVersion === FlowBuilderJSONVersion.LATEST,
+    }
     const customFunctions = options.customFunctions || {}
     this.functions = { ...DEFAULT_FUNCTIONS, ...customFunctions }
   }
@@ -86,18 +95,35 @@ export default class BotonicPluginFlowBuilder implements Plugin {
       const nodeByUserInput = await getNodeByUserInput(
         this.cmsApi,
         resolvedLocale,
-        request as unknown as ActionRequest
+        request as unknown as ActionRequest,
+        this.smartIntentsConfig
       )
       request.input.payload = this.cmsApi.getPayload(nodeByUserInput?.target)
     }
 
+    this.updateRequestBeforeRoutes(request)
+  }
+
+  private updateRequestBeforeRoutes(request: PluginPreRequest) {
     if (request.input.payload) {
-      request.input.payload = request.input.payload?.split(
-        SOURCE_INFO_SEPARATOR
-      )[0]
+      request.input.payload = this.removeSourceSufix(request.input.payload)
+
+      if (request.input.payload.startsWith(BOT_ACTION_PAYLOAD_PREFIX)) {
+        request.input.payload = this.replacePayload(request.input.payload)
+      }
     }
   }
 
+  private removeSourceSufix(payload: string): string {
+    return payload.split(SOURCE_INFO_SEPARATOR)[0]
+  }
+
+  private replacePayload(payload: string): string {
+    const botActionId = payload.split(SEPARATOR)[1]
+    const botActionNode = this.cmsApi.getNodeById<HtBotActionNode>(botActionId)
+    return this.cmsApi.createPayloadWithParams(botActionNode)
+  }
+
   async getContentsByContentID(
     contentID: string,
     locale: string,
@@ -122,8 +148,19 @@ export default class BotonicPluginFlowBuilder implements Plugin {
   }
 
   async getStartContents(locale: string): Promise<FlowContent[]> {
+    const resolvedLocale = this.cmsApi.getResolvedLocale(locale)
     const startNode = this.cmsApi.getStartNode()
-    return await this.getContentsByNode(startNode, locale)
+    this.currentRequest.session.flow_thread_id = uuid()
+    const eventArgs = getNodeEventArgs(
+      this.currentRequest as unknown as ActionRequest,
+      startNode
+    )
+    await trackEvent(
+      this.currentRequest as unknown as ActionRequest,
+      EventAction.flowNode,
+      eventArgs
+    )
+    return await this.getContentsByNode(startNode, resolvedLocale)
   }
 
   async getContentsByNode(
@@ -239,6 +276,10 @@ export default class BotonicPluginFlowBuilder implements Plugin {
     const payloadParams = JSON.parse(payload.split(SEPARATOR)[1] || '{}')
     return payloadParams
   }
+
+  getFlowName(flowId: string): string {
+    return this.cmsApi.getFlowName(flowId)
+  }
 }
 
 export * from './action'

package/src/tracking.ts

@@ -1,32 +1,43 @@
 import { ActionRequest } from '@botonic/react'
 
+import { HtNodeWithContent } from './content-fields/hubtype-fields'
 import { getFlowBuilderPlugin } from './helpers'
 
 export async function trackEvent(
   request: ActionRequest,
-  eventName: EventName,
+  eventAction: EventAction,
   args?: Record<string, any>
 ): Promise<void> {
   const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
   if (flowBuilderPlugin.trackEvent) {
-    await flowBuilderPlugin.trackEvent(request, eventName, args)
+    await flowBuilderPlugin.trackEvent(request, eventAction, args)
   }
   return
 }
 
-export enum EventName {
-  botAgentRating = 'bot_agent_rating',
-  botChannelRating = 'bot_channel_rating',
-  botFaqUseful = 'bot_faq_useful',
-  botRating = 'bot_rating',
-  botFaq = 'bot_faq',
-  botStart = 'bot_start',
-  botOpen = 'bot_open',
-  botAiModel = 'bot_ai_model',
-  botAiKnowledgeBase = 'bot_ai_knowledge_base',
-  botKeywordsModel = 'bot_keywords_model',
-  fallback = 'fallback',
+export function getNodeEventArgs(
+  request: ActionRequest,
+  node: HtNodeWithContent
+) {
+  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
+  return {
+    flowThreadId: request.session.flow_thread_id,
+    flowId: node.flow_id,
+    flowName: flowBuilderPlugin.getFlowName(node.flow_id),
+    flowNodeId: node.id,
+    flowNodeContentId: node.code,
+    flowNodeIsMeaningful: undefined, //node?.isMeaningful,
+  }
+}
+
+export enum EventAction {
+  flowNode = 'flow_node',
   handoffOption = 'handoff_option',
   handoffSuccess = 'handoff_success',
   handoffFail = 'handoff_fail',
+  keyword = 'nlu_keyword',
+  intent = 'nlu_intent',
+  intentSmart = 'nlu_intent_smart',
+  knowledgebase = 'knowledgebase',
+  fallback = 'fallback',
 }