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

package/src/user-input/keyword.ts

@@ -1,22 +1,101 @@
 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) {
+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
+  }
+
+  private getNodeByKeyword(
+    userInput: string,
+    keywordNodes: HtKeywordNode[]
+  ): HtKeywordNode | undefined {
+    const matchedKeywordNodes = keywordNodes.filter(node =>
+      this.matchKeywords(userInput, node)
+    )
+
+    if (matchedKeywordNodes.length > 0 && matchedKeywordNodes[0].target) {
+      return matchedKeywordNodes[0]
+    }
+
     return undefined
   }
-  const eventArgs = {
-    confidence_successful: true,
+
+  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,
+          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
   }
 }