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

package/src/action/index.tsx

@@ -5,7 +5,8 @@ import { FlowBuilderApi } from '../api'
 import { FlowContent, FlowHandoff } from '../content-fields'
 import { HtNodeWithContent } from '../content-fields/hubtype-fields'
 import { getFlowBuilderPlugin } from '../helpers'
-import { EventName, trackEvent } from '../tracking'
+import BotonicPluginFlowBuilder from '../index'
+import { EventAction, trackEvent, trackFlowContent } from '../tracking'
 import { createNodeFromKnowledgeBase } from './knowledge-bases'
 
 export type FlowBuilderActionProps = {
@@ -18,20 +19,14 @@ 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
     ) as FlowHandoff
-    if (handoffContent) await handoffContent.doHandoff(request)
+    if (handoffContent) {
+      await handoffContent.doHandoff(request)
+    }
 
     return { contents }
   }
@@ -55,26 +50,73 @@ 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 contents = await flowBuilderPlugin.getContentsByNode(
+      targetNode,
+      resolvedLocale
+    )
+    await trackFlowContent(request, contents)
+
+    return contents
   }
-  return await getFallbackNode(cmsApi, request)
+
+  return []
+}
+
+async function getContentsByFallback({
+  cmsApi,
+  flowBuilderPlugin,
+  request,
+  resolvedLocale,
+}: FlowBuilderContext): Promise<FlowContent[]> {
+  const fallbackNode = await getFallbackNode(cmsApi, request)
+  const fallbackContents = await flowBuilderPlugin.getContentsByNode(
+    fallbackNode,
+    resolvedLocale
+  )
+  await trackFlowContent(request, fallbackContents)
+
+  return fallbackContents
 }
 
 async function getFallbackNode(cmsApi: FlowBuilderApi, request: ActionRequest) {
@@ -95,6 +137,10 @@ 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, {
+    fallbackOut: isFirstFallbackOption ? 1 : 2,
+    fallbackMessageId: request.input.message_id,
+  })
+
   return fallbackNode
 }

package/src/action/knowledge-bases.ts

@@ -9,7 +9,8 @@ import {
   HtTextNode,
 } from '../content-fields/hubtype-fields'
 import { getFlowBuilderPlugin } from '../helpers'
-import { EventName, trackEvent } from '../tracking'
+import { EventAction, KnowledgebaseFailReason, trackEvent } from '../tracking'
+import { KnowledgeBaseResponse } from '../types'
 
 export async function createNodeFromKnowledgeBase(
   cmsApi: FlowBuilderApi,
@@ -27,14 +28,12 @@ export async function createNodeFromKnowledgeBase(
     try {
       const knowledgeBaseResponse =
         await flowBuilderPlugin.getKnowledgeBaseResponse(request)
-      if (knowledgeBaseResponse.hasKnowledge) {
-        await trackEvent(request, EventName.botAiKnowledgeBase, {
-          answer: knowledgeBaseResponse.answer,
-          knowledge_source_ids: knowledgeBaseResponse.sources.map(
-            source => source.knowledgeSourceId
-          ),
-        })
+      await trackKnowledgeBase(knowledgeBaseResponse, request)
 
+      if (
+        knowledgeBaseResponse.hasKnowledge &&
+        knowledgeBaseResponse.isFaithuful
+      ) {
         const knowledgeBaseNode: HtTextNode = {
           type: HtNodeWithContentType.TEXT,
           content: {
@@ -59,9 +58,44 @@ export async function createNodeFromKnowledgeBase(
         return knowledgeBaseNode
       }
     } catch (e) {
-      console.log('Hubtype knowledge base api error: ', { e })
-      return undefined
+      console.error('Hubtype knowledge base api error: ', { e })
     }
   }
   return undefined
 }
+
+async function trackKnowledgeBase(
+  response: KnowledgeBaseResponse,
+  request: ActionRequest
+) {
+  /*  TODO:
+      In order to have all these parameters in the base knowlege response 
+      it is necessary to use the new endpoint to which the knowledge sources 
+      have to be indicated. For now this will not work, we need to finish 
+      the knowldege base node in the flow builder frontend.
+  */
+  const knowledgebaseInferenceId = response.inferenceId
+  const knowledgebaseSourcesIds = response.sources.map(
+    source => source.knowledgeSourceId
+  )
+  const knowledgebaseChunksIds = response.sources.map(
+    source => source.knowledgeChunkId
+  )
+  const knowledgebaseMessageId = request.input.message_id
+
+  let knowledgebaseFailReason: KnowledgebaseFailReason | undefined
+  if (!response.isFaithuful) {
+    knowledgebaseFailReason = KnowledgebaseFailReason.Hallucination
+  }
+  if (!response.hasKnowledge) {
+    knowledgebaseFailReason = KnowledgebaseFailReason.NoKnowledge
+  }
+
+  await trackEvent(request, EventAction.Knowledgebase, {
+    knowledgebaseInferenceId,
+    knowledgebaseFailReason,
+    knowledgebaseSourcesIds,
+    knowledgebaseChunksIds,
+    knowledgebaseMessageId,
+  })
+}

package/src/api.ts

@@ -1,11 +1,7 @@
 import { Input, PluginPreRequest } from '@botonic/core'
 import axios from 'axios'
 
-import {
-  BOT_ACTION_PAYLOAD_SEPARATOR,
-  REG_EXP_PATTERN,
-  SEPARATOR,
-} from './constants'
+import { BOT_ACTION_PAYLOAD_PREFIX, SEPARATOR } from './constants'
 import {
   HtBotActionNode,
   HtFallbackNode,
@@ -154,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 {
@@ -213,7 +162,7 @@ export class FlowBuilderApi {
     }
 
     if (target.type === HtNodeWithoutContentType.BOT_ACTION) {
-      return `${BOT_ACTION_PAYLOAD_SEPARATOR}${target.id}`
+      return `${BOT_ACTION_PAYLOAD_PREFIX}${target.id}`
     }
 
     return target.id
@@ -250,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,7 +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_SEPARATOR = `ba${SEPARATOR}`
+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-handoff.tsx

@@ -3,10 +3,8 @@ import { ActionRequest, WebchatSettings } from '@botonic/react'
 import React from 'react'
 
 import { FlowBuilderApi } from '../api'
-import { getQueueAvailability } from '../functions/conditional-queue-status'
-import { EventName, trackEvent } from '../tracking'
 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/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

@@ -27,7 +27,32 @@ export async function conditionalQueueStatus({
   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 +65,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,9 +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_SEPARATOR,
+  BOT_ACTION_PAYLOAD_PREFIX,
   FLOW_BUILDER_API_URL_PROD,
   SEPARATOR,
   SOURCE_INFO_SEPARATOR,
@@ -29,6 +30,7 @@ import {
   HtNodeWithContentType,
 } from './content-fields/hubtype-fields'
 import { DEFAULT_FUNCTIONS } from './functions'
+import { trackFlowContent } from './tracking'
 import {
   BotonicPluginFlowBuilderOptions,
   FlowBuilderJSONVersion,
@@ -36,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
@@ -48,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
@@ -64,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 }
   }
@@ -88,7 +95,8 @@ 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)
     }
@@ -98,25 +106,22 @@ export default class BotonicPluginFlowBuilder implements Plugin {
 
   private updateRequestBeforeRoutes(request: PluginPreRequest) {
     if (request.input.payload) {
-      request.input.payload = this.removeSourceSeparatorFromPayload(
-        request.input.payload
-      )
-      request.input.payload = this.updateBotActionPayload(request.input.payload)
+      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 removeSourceSeparatorFromPayload(payload: string): string {
-    return payload?.split(SOURCE_INFO_SEPARATOR)[0]
+  private removeSourceSufix(payload: string): string {
+    return payload.split(SOURCE_INFO_SEPARATOR)[0]
   }
 
-  private updateBotActionPayload(payload: string): string {
-    if (payload.startsWith(BOT_ACTION_PAYLOAD_SEPARATOR)) {
-      const botActionId = payload.split(SEPARATOR)[1]
-      const botActionNode =
-        this.cmsApi.getNodeById<HtBotActionNode>(botActionId)
-      return this.cmsApi.createPayloadWithParams(botActionNode)
-    }
-    return payload
+  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(
@@ -143,8 +148,16 @@ 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 contents = await this.getContentsByNode(startNode, resolvedLocale)
+
+    await trackFlowContent(
+      this.currentRequest as unknown as ActionRequest,
+      contents
+    )
+    return contents
   }
 
   async getContentsByNode(
@@ -260,6 +273,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,68 @@
 import { ActionRequest } from '@botonic/react'
 
+import { FlowContent } from './content-fields'
+import { HtNodeWithContent } from './content-fields/hubtype-fields'
 import { getFlowBuilderPlugin } from './helpers'
 
+export enum EventAction {
+  FlowNode = 'flow_node',
+  Keyword = 'nlu_keyword',
+  Intent = 'nlu_intent',
+  IntentSmart = 'nlu_intent_smart',
+  Knowledgebase = 'knowledgebase',
+  Fallback = 'fallback',
+}
+
+export enum KnowledgebaseFailReason {
+  NoKnowledge = 'no_knowledge',
+  Hallucination = 'hallucination',
+}
+
 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',
-  handoffOption = 'handoff_option',
-  handoffSuccess = 'handoff_success',
-  handoffFail = 'handoff_fail',
+export async function trackFlowContent(
+  request: ActionRequest,
+  contents: FlowContent[]
+) {
+  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
+  const cmsApi = flowBuilderPlugin.cmsApi
+  const firstNodeContent = cmsApi.getNodeById<HtNodeWithContent>(contents[0].id)
+  const flowName = flowBuilderPlugin.getFlowName(firstNodeContent.flow_id)
+  const eventArgs = getContentEventArgs(request, {
+    code: firstNodeContent.code,
+    flowId: firstNodeContent.flow_id,
+    flowName,
+    id: firstNodeContent.id,
+  })
+  await trackEvent(request, EventAction.FlowNode, eventArgs)
+}
+
+export function getContentEventArgs(
+  request: ActionRequest,
+  contentInfo: {
+    code: string
+    flowId: string
+    flowName: string
+    id: string
+  }
+) {
+  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
+  return {
+    flowThreadId: request.session.flow_thread_id,
+    flowId: contentInfo.flowId,
+    flowName: flowBuilderPlugin.getFlowName(contentInfo.flowId),
+    flowNodeId: contentInfo.id,
+    flowNodeContentId: contentInfo.code,
+    flowNodeIsMeaningful: undefined, //node?.isMeaningful,
+  }
 }