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

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 {
@@ -38,14 +39,29 @@ export enum FlowBuilderJSONVersion {
 }
 
 export interface KnowledgeBaseResponse {
+  inferenceId: string
+  question: string
   answer: string
   hasKnowledge: boolean
+  isFaithuful: boolean
   sources: {
+    knowledgeBaseId: string
     knowledgeSourceId: string
-    page?: number
+    knowledgeChunkId: string
   }[]
 }
 
+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 = await 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,

package/src/user-input/keyword.ts

@@ -1,22 +1,97 @@
 import { ActionRequest } from '@botonic/react'
 
 import { FlowBuilderApi } from '../api'
+import { REG_EXP_PATTERN } from '../constants'
 import { HtKeywordNode } from '../content-fields/hubtype-fields'
-import { EventName, trackEvent } from '../tracking'
-
-export async function getKeywordNodeByInput(
-  cmsApi: FlowBuilderApi,
-  locale: string,
-  request: ActionRequest,
-  userInput: string
-): Promise<HtKeywordNode | undefined> {
-  const keywordNode = cmsApi.getNodeByKeyword(userInput, locale)
-  if (!keywordNode) {
-    return undefined
+import { EventAction, trackEvent } from '../tracking'
+
+interface KeywordProps {
+  cmsApi: FlowBuilderApi
+  locale: string
+  request: ActionRequest
+}
+export class KeywordMatcher {
+  public cmsApi: FlowBuilderApi
+  public locale: string
+  public request: ActionRequest
+  public isRegExp: boolean
+  public matchedKeyword?: string
+  public keywordNodeId?: string
+
+  constructor({ cmsApi, locale, request }: KeywordProps) {
+    this.cmsApi = cmsApi
+    this.locale = locale
+    this.request = request
+    this.isRegExp = false
+  }
+
+  async getNodeByInput(userInput: string): Promise<HtKeywordNode | undefined> {
+    const keywordNodes = this.cmsApi.getKeywordNodes()
+    const keywordNode = this.getNodeByKeyword(userInput, keywordNodes)
+    if (!keywordNode) {
+      return undefined
+    }
+    this.trackKeywordEvent()
+    return keywordNode
   }
-  const eventArgs = {
-    confidence_successful: true,
+
+  private getNodeByKeyword(
+    userInput: string,
+    keywordNodes: HtKeywordNode[]
+  ): HtKeywordNode | undefined {
+    const matchedKeywordNode = keywordNodes.find(node =>
+      this.matchKeywords(userInput, node)
+    )
+
+    return matchedKeywordNode?.target ? matchedKeywordNode : undefined
+  }
+
+  private matchKeywords(userInput: string, node: HtKeywordNode): boolean {
+    const result = node.content.keywords.find(keywords => {
+      if (keywords.locale === this.locale) {
+        this.keywordNodeId = node.id
+        return this.inputMatchesAnyKeyword(userInput, keywords.values)
+      }
+
+      return false
+    })
+
+    return Boolean(result)
+  }
+
+  private inputMatchesAnyKeyword(
+    userInput: string,
+    keywords: string[]
+  ): boolean {
+    return keywords.some(keyword => {
+      const regExpMatchArray = keyword.match(REG_EXP_PATTERN)
+
+      if (regExpMatchArray) {
+        const keywordAsRegExp = this.resolveKeywordAsRegExp(regExpMatchArray)
+        const match = userInput.match(keywordAsRegExp)
+        this.isRegExp = true
+        this.matchedKeyword = match ? match[0] : undefined
+      } else {
+        this.isRegExp = false
+        this.matchedKeyword = userInput.includes(keyword) ? keyword : undefined
+      }
+
+      return this.matchedKeyword !== undefined
+    })
+  }
+
+  private resolveKeywordAsRegExp(regExpMatchArray: RegExpMatchArray): RegExp {
+    const [, pattern, flags] = regExpMatchArray
+    return new RegExp(pattern, flags)
+  }
+
+  private async trackKeywordEvent() {
+    const eventArgs = {
+      nluKeywordId: this.keywordNodeId,
+      nluKeywordName: this.matchedKeyword,
+      nluKeywordIsRegex: this.isRegExp,
+      nluKeywordMessageId: this.request.input.message_id,
+    }
+    await trackEvent(this.request, EventAction.Keyword, eventArgs)
   }
-  await trackEvent(request, EventName.botKeywordsModel, eventArgs)
-  return keywordNode
 }

package/src/user-input/smart-intent.ts

@@ -3,44 +3,72 @@ import axios from 'axios'
 
 import { FlowBuilderApi } from '../api'
 import { HtSmartIntentNode } from '../content-fields/hubtype-fields/smart-intent'
+import { EventAction, trackEvent } from '../tracking'
+import { SmartIntentResponse } from '../types'
 
-export async function getSmartIntentNodeByInput(
-  cmsApi: FlowBuilderApi,
-  request: ActionRequest
-): Promise<HtSmartIntentNode | undefined> {
-  const smartIntentNodes = cmsApi.getSmartIntentNodes()
-  if (smartIntentNodes.length === 0) {
+export interface SmartIntentsInferenceParams {
+  bot_id: string
+  text: string
+  num_smart_intents_to_use?: number
+  use_latest: boolean
+}
+
+export interface SmartIntentsInferenceConfig {
+  useLatest: boolean
+  numSmartIntentsToUse?: number
+}
+
+export class SmartIntentsApi {
+  constructor(
+    public cmsApi: FlowBuilderApi,
+    public currentRequest: ActionRequest,
+    public smartIntentsConfig: SmartIntentsInferenceConfig
+  ) {}
+
+  async getNodeByInput(): Promise<HtSmartIntentNode | undefined> {
+    if (!this.currentRequest.input.data) return undefined
+    const smartIntentNodes = this.cmsApi.getSmartIntentNodes()
+    if (!smartIntentNodes.length) return undefined
+
+    const params = {
+      bot_id: this.currentRequest.session.bot.id,
+      text: this.currentRequest.input.data,
+      num_smart_intents_to_use: this.smartIntentsConfig.numSmartIntentsToUse,
+      use_latest: this.smartIntentsConfig.useLatest,
+    }
+
+    try {
+      const response = await this.getInference(params)
+      const smartIntentNode = smartIntentNodes.find(
+        smartIntentNode =>
+          smartIntentNode.content.title === response.data.smart_intent_title
+      )
+      if (smartIntentNode) {
+        trackEvent(this.currentRequest, EventAction.IntentSmart, {
+          nluIntentSmartTitle: response.data.smart_intent_title,
+          nluIntentSmartNumUsed: response.data.smart_intents_used.length,
+          nluIntentSmartMessageId: this.currentRequest.input.message_id,
+        })
+        return smartIntentNode
+      }
+    } catch (e) {
+      console.error(e)
+    }
     return undefined
   }
 
-  const intentsInferenceParams = smartIntentNodes.map(smartIntentNode => {
-    return {
-      name: smartIntentNode.content.title,
-      definition: smartIntentNode.content.description,
-    }
-  })
-  intentsInferenceParams.push({
-    name: 'Other',
-    definition: 'The text does not belong to any other intent.',
-  })
-
-  try {
-    const response = await axios({
+  private async getInference(
+    inferenceParams: SmartIntentsInferenceParams
+  ): Promise<SmartIntentResponse> {
+    return await axios({
       method: 'POST',
-      url: `${process.env.HUBTYPE_API_URL}/external/v1/ai/smart_intents/inference/`,
+      url: `${process.env.HUBTYPE_API_URL}/external/v2/ai/smart_intents/inference/`,
       headers: {
-        Authorization: `Bearer ${request.session._access_token}`,
+        Authorization: `Bearer ${this.currentRequest.session._access_token}`,
         'Content-Type': 'application/json',
       },
-      data: { text: request.input.data, intents: intentsInferenceParams },
+      data: inferenceParams,
       timeout: 10000,
     })
-    return smartIntentNodes.find(
-      smartIntentNode =>
-        smartIntentNode.content.title === response.data.intent_name
-    )
-  } catch (e) {
-    console.error(e)
-    return undefined
   }
 }