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

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

@@ -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,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 { EventAction, getNodeEventArgs, trackEvent } 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,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(
@@ -260,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',
 }

package/src/types.ts

@@ -12,12 +12,13 @@ export interface BotonicPluginFlowBuilderOptions {
   getAccessToken: () => string
   trackEvent?: (
     request: ActionRequest,
-    eventName: string,
+    eventAction: string,
     args?: Record<string, any>
   ) => Promise<void>
   getKnowledgeBaseResponse?: (
     request: ActionRequest
   ) => Promise<KnowledgeBaseResponse>
+  smartIntentsConfig?: { numSmartIntentsToUse: number }
 }
 
 export interface FlowBuilderApiOptions {
@@ -46,6 +47,17 @@ export interface KnowledgeBaseResponse {
   }[]
 }
 
+export interface SmartIntentResponse {
+  data: {
+    smart_intent_title: string
+    text: string
+    smart_intents_used: {
+      title: string
+      description: string
+    }[]
+  }
+}
+
 export interface PayloadParamsBase {
   followUpContentID?: string
 }

package/src/user-input/index.ts

@@ -7,24 +7,30 @@ import {
   HtSmartIntentNode,
 } from '../content-fields/hubtype-fields'
 import { getIntentNodeByInput } from './intent'
-import { getKeywordNodeByInput } from './keyword'
-import { getSmartIntentNodeByInput } from './smart-intent'
+import { KeywordMatcher } from './keyword'
+import { SmartIntentsApi, SmartIntentsInferenceConfig } from './smart-intent'
 
 export async function getNodeByUserInput(
   cmsApi: FlowBuilderApi,
   locale: string,
-  request: ActionRequest
+  request: ActionRequest,
+  smartIntentsConfig: SmartIntentsInferenceConfig
 ): Promise<HtSmartIntentNode | HtIntentNode | HtKeywordNode | undefined> {
   if (request.input.data) {
-    const keywordNode = await getKeywordNodeByInput(
+    const keywordMatcher = new KeywordMatcher({
       cmsApi,
       locale,
       request,
-      request.input.data
-    )
+    })
+    const keywordNode = await keywordMatcher.getNodeByInput(request.input.data)
     if (keywordNode) return keywordNode
 
-    const smartIntentNode = await getSmartIntentNodeByInput(cmsApi, request)
+    const smartIntentsApi = new SmartIntentsApi(
+      cmsApi,
+      request,
+      smartIntentsConfig
+    )
+    const smartIntentNode = smartIntentsApi.getNodeByInput()
     if (smartIntentNode) return smartIntentNode
 
     const intentNode = await getIntentNodeByInput(cmsApi, locale, request)

package/src/user-input/intent.ts

@@ -2,7 +2,7 @@ import { ActionRequest } from '@botonic/react'
 
 import { FlowBuilderApi } from '../api'
 import { HtIntentNode } from '../content-fields/hubtype-fields'
-import { EventName, trackEvent } from '../tracking'
+import { EventAction, trackEvent } from '../tracking'
 
 export async function getIntentNodeByInput(
   cmsApi: FlowBuilderApi,
@@ -10,24 +10,31 @@ export async function getIntentNodeByInput(
   request: ActionRequest
 ): Promise<HtIntentNode | undefined> {
   const intentNode = cmsApi.getIntentNode(request.input, locale)
-  const eventArgs = {
-    intent: request.input.intent as string,
-    confidence: request.input.confidence as number,
-    confidence_successful: true,
-  }
+
   if (request.input.confidence && request.input.intent && intentNode) {
+    await trackIntentEvent(request, intentNode)
+
     if (isIntentValid(intentNode, request, cmsApi)) {
-      await trackEvent(request, EventName.botAiModel, eventArgs)
       return intentNode
     }
-
-    eventArgs.confidence_successful = false
-    await trackEvent(request, EventName.botAiModel, eventArgs)
   }
 
   return undefined
 }
 
+async function trackIntentEvent(
+  request: ActionRequest,
+  intentNode: HtIntentNode
+) {
+  const eventArgs = {
+    nluIntentLabel: request.input.intent,
+    nluIntentConfidence: request.input.confidence,
+    nluIntentThreshold: intentNode?.content.confidence,
+    nluIntentMessageId: request.input.message_id,
+  }
+  await trackEvent(request, EventAction.intent, eventArgs)
+}
+
 function isIntentValid(
   intentNode: HtIntentNode,
   request: ActionRequest,