@botonic/plugin-flow-builder 0.46.2 → 2.23.1

package/src/types.ts

@@ -1,117 +0,0 @@
-import {
-  AiAgentArgs,
-  type BotContext,
-  GuardrailRule,
-  type InferenceResponse,
-  type KnowledgeBasesResponse,
-  type PluginPreRequest,
-  type ResolvedPlugins,
-} from '@botonic/core'
-import type { FlowBuilderContentMessage } from './action/ai-agent/structured-output/flow-builder-content'
-import type { FlowContent } from './content-fields'
-import type {
-  HtFlowBuilderData,
-  HtRatingButton,
-} from './content-fields/hubtype-fields'
-
-export interface InShadowingConfig {
-  allowKeywords: boolean
-  allowSmartIntents: boolean
-  allowKnowledgeBases: boolean
-  allowAiAgents: boolean
-}
-
-export interface BotonicPluginFlowBuilderOptions<
-  TPlugins extends ResolvedPlugins = ResolvedPlugins,
-  TExtraData = any,
-> {
-  apiUrl?: string
-  jsonVersion?: FlowBuilderJSONVersion
-  flow?: HtFlowBuilderData
-  customFunctions?: Record<any, any>
-  getAccessToken: () => string
-  trackEvent?: TrackEventFunction<TPlugins, TExtraData>
-  getKnowledgeBaseResponse?: KnowledgeBaseFunction<TPlugins, TExtraData>
-  getAiAgentResponse?: AiAgentFunction<TPlugins, TExtraData>
-  smartIntentsConfig?: { numSmartIntentsToUse: number }
-  inShadowing?: Partial<InShadowingConfig>
-  contentFilters?: ContentFilter<TPlugins, TExtraData>[]
-  customRatingMessageEnabled?: boolean
-  disableAIAgentInFirstInteraction?: boolean
-}
-
-export type TrackEventFunction<
-  TPlugins extends ResolvedPlugins = ResolvedPlugins,
-  TExtraData = any,
-> = (
-  request: BotContext<TPlugins, TExtraData>,
-  eventAction: string,
-  args?: Record<string, any>
-) => Promise<void>
-
-export type KnowledgeBaseFunction<
-  TPlugins extends ResolvedPlugins = ResolvedPlugins,
-  TExtraData = any,
-> = (
-  request: BotContext<TPlugins, TExtraData>,
-  sources: string[],
-  instructions: string,
-  messageId: string,
-  memoryLength: number
-) => Promise<KnowledgeBasesResponse>
-
-export type AiAgentFunction<
-  TPlugins extends ResolvedPlugins = ResolvedPlugins,
-  TExtraData = any,
-> = (
-  request: BotContext<TPlugins, TExtraData>,
-  aiAgentArgs: AiAgentArgs
-) => Promise<InferenceResponse<FlowBuilderContentMessage>>
-
-export type ContentFilter<
-  TPlugins extends ResolvedPlugins = ResolvedPlugins,
-  TExtraData = any,
-> = (
-  request: BotContext<TPlugins, TExtraData>,
-  content: FlowContent
-) => Promise<FlowContent> | FlowContent
-
-export interface FlowBuilderApiOptions {
-  url: string
-  flowUrl: string
-  flow?: HtFlowBuilderData
-  accessToken: string
-  request: PluginPreRequest
-}
-
-export enum ProcessEnvNodeEnvs {
-  PRODUCTION = 'production',
-  DEVELOPMENT = 'development',
-}
-
-export enum FlowBuilderJSONVersion {
-  DRAFT = 'draft',
-  LATEST = 'latest',
-}
-
-export interface SmartIntentResponse {
-  data: {
-    smart_intent_title: string
-    text: string
-    smart_intents_used: {
-      title: string
-      description: string
-    }[]
-  }
-}
-
-export interface PayloadParamsBase {
-  followUpContentID?: string
-}
-
-export interface RatingSubmittedInfo extends HtRatingButton {
-  possibleOptions: string[]
-  possibleValues: number[]
-}
-
-export { AiAgentArgs, GuardrailRule }

package/src/user-input/capture-user-input-api.ts

@@ -1,144 +0,0 @@
-import { EventAction, type EventCaptureUserInput } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-import axios from 'axios'
-
-import type { FlowBuilderApi } from '../api'
-import { FlowCaptureUserInput } from '../content-fields'
-import {
-  HtAiValidationType,
-  type HtCaptureUserInputNode,
-} from '../content-fields/hubtype-fields'
-import { getFlowBuilderPlugin } from '../helpers'
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import { inputHasTextOrTranscript } from '../utils'
-
-interface AiCaptureResponseSuccess {
-  success: true
-  value: string
-}
-
-interface AiCaptureResponseFailure {
-  success: false
-}
-
-type AiCaptureResponse = AiCaptureResponseSuccess | AiCaptureResponseFailure
-
-export class CaptureUserInputApi {
-  private cmsApi: FlowBuilderApi
-  private request: ActionRequest
-  private textOrTranscript: string
-
-  constructor(
-    cmsApi: FlowBuilderApi,
-    request: ActionRequest,
-    textOrTranscript: string
-  ) {
-    this.cmsApi = cmsApi
-    this.request = request
-    this.textOrTranscript = textOrTranscript
-  }
-
-  async getNextNodeId(): Promise<string | undefined> {
-    if (
-      inputHasTextOrTranscript(this.request.input) &&
-      this.cmsApi.shouldCaptureUserInput()
-    ) {
-      const captureUserInputNode = this.cmsApi.getCaptureUserInputNode()
-      if (!captureUserInputNode || !this.textOrTranscript) {
-        return undefined
-      }
-      const captureUserInput =
-        FlowCaptureUserInput.fromHubtypeCMS(captureUserInputNode)
-
-      if (captureUserInput.aiValidationType === HtAiValidationType.NONE) {
-        this.cmsApi.setUserExtraDataVariable(
-          captureUserInputNode.content.field_name,
-          this.textOrTranscript
-        )
-        await this.trackUserInputCapture(captureUserInputNode, true)
-        return captureUserInput.captureSuccessId
-      }
-
-      const aiCaptureResponse =
-        await this.getAiCaptureResponse(captureUserInputNode)
-      if (!aiCaptureResponse.success) {
-        await this.trackUserInputCapture(captureUserInputNode, false)
-        return captureUserInput.captureFailId
-      }
-
-      this.cmsApi.setUserExtraDataVariable(
-        captureUserInputNode.content.field_name,
-        aiCaptureResponse.value
-      )
-      await this.trackUserInputCapture(captureUserInputNode, true)
-      return captureUserInput.captureSuccessId
-    }
-    return undefined
-  }
-
-  async getAiCaptureResponse(
-    captureUserInputNode: HtCaptureUserInputNode
-  ): Promise<AiCaptureResponse> {
-    try {
-      const url = `${process.env.HUBTYPE_API_URL}/external/v1/capture_user_input/`
-      const data = {
-        field_name: captureUserInputNode.content.field_name,
-        validation_instructions:
-          captureUserInputNode.content.ai_validation_instructions,
-        user_input: this.textOrTranscript,
-      }
-      const pluginFlowBuilder = getFlowBuilderPlugin(this.request.plugins)
-      const token = pluginFlowBuilder.getAccessToken(this.request.session)
-
-      const config = {
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${token}`,
-        },
-      }
-
-      const aiCaptureResponse = await axios.post<AiCaptureResponse>(
-        url,
-        data,
-        config
-      )
-
-      return aiCaptureResponse.data
-    } catch (error) {
-      console.warn('Error getting ai/capture_user_input', error)
-    }
-
-    return {
-      success: false,
-    }
-  }
-
-  async trackUserInputCapture(
-    captureUserInputNode: HtCaptureUserInputNode,
-    captureSuccess: boolean
-  ): Promise<void> {
-    const { flowThreadId, flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(
-        this.request,
-        captureUserInputNode.id
-      )
-    const event: EventCaptureUserInput = {
-      action: EventAction.CaptureUserInput,
-      flowThreadId,
-      flowId,
-      flowName,
-      flowNodeId,
-      flowNodeContentId,
-      flowNodeIsMeaningful: false,
-      fieldName: captureUserInputNode.content.field_name,
-      userInput: this.request.input.data as string,
-      captureSuccess,
-      messageId: this.request.input.message_id,
-    }
-    const { action, ...eventArgs } = event
-    await trackEvent(this.request, action, eventArgs)
-  }
-}

package/src/user-input/index.ts

@@ -1,61 +0,0 @@
-import type { ActionRequest } from '@botonic/react'
-
-import type { FlowBuilderApi } from '../api'
-import {
-  getTextOrTranscript,
-  isKeywordsAllowed,
-  isSmartIntentsAllowed,
-} from '../utils'
-import { CaptureUserInputApi } from './capture-user-input-api'
-import { KeywordMatcher } from './keyword'
-import {
-  SmartIntentsApi,
-  type SmartIntentsInferenceConfig,
-} from './smart-intent'
-
-export async function getNextPayloadByUserInput(
-  cmsApi: FlowBuilderApi,
-  locale: string,
-  request: ActionRequest,
-  smartIntentsConfig: SmartIntentsInferenceConfig
-): Promise<string | undefined> {
-  const userTextOrTranscript = getTextOrTranscript(request.input)
-  if (userTextOrTranscript) {
-    if (cmsApi.shouldCaptureUserInput()) {
-      const captureUserInputApi = new CaptureUserInputApi(
-        cmsApi,
-        request,
-        userTextOrTranscript
-      )
-      return await captureUserInputApi.getNextNodeId()
-    }
-
-    if (isKeywordsAllowed(request)) {
-      const keywordMatcher = new KeywordMatcher({
-        cmsApi,
-        locale,
-        request,
-        userTextOrTranscript,
-      })
-      const keywordNode = await keywordMatcher.getNodeByInput()
-      if (keywordNode) {
-        return cmsApi.getPayload(keywordNode.target)
-      }
-    }
-
-    if (isSmartIntentsAllowed(request)) {
-      const smartIntentsApi = new SmartIntentsApi(
-        cmsApi,
-        request,
-        smartIntentsConfig,
-        userTextOrTranscript
-      )
-      const smartIntentNode = await smartIntentsApi.getNodeByInput()
-      if (smartIntentNode) {
-        return cmsApi.getPayload(smartIntentNode.target)
-      }
-    }
-  }
-
-  return undefined
-}

package/src/user-input/keyword.ts

@@ -1,134 +0,0 @@
-import { EventAction, type EventKeyword, NluType } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-
-import type { FlowBuilderApi } from '../api'
-import { REG_EXP_PATTERN } from '../constants'
-import type {
-  HtKeywordNode,
-  HtNodeWithContent,
-} from '../content-fields/hubtype-fields'
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-
-interface KeywordProps {
-  cmsApi: FlowBuilderApi
-  locale: string
-  request: ActionRequest
-  userTextOrTranscript: string
-}
-export class KeywordMatcher {
-  public cmsApi: FlowBuilderApi
-  public locale: string
-  public request: ActionRequest
-  public isRegExp: boolean
-  public matchedKeyword?: string
-  public keywordNodeId?: string
-  public flowId?: string
-  public userTextOrTranscript: string
-
-  constructor({ cmsApi, locale, request, userTextOrTranscript }: KeywordProps) {
-    this.cmsApi = cmsApi
-    this.locale = locale
-    this.request = request
-    this.isRegExp = false
-    this.userTextOrTranscript = userTextOrTranscript
-  }
-
-  async getNodeByInput(): Promise<HtKeywordNode | undefined> {
-    const keywordNodes = this.cmsApi.getKeywordNodes()
-    const keywordNode = this.getNodeByKeyword(
-      this.userTextOrTranscript,
-      keywordNodes
-    )
-    if (!keywordNode || !this.matchedKeyword) {
-      return undefined
-    }
-    const targetPayload = this.cmsApi.getPayload(keywordNode.target)
-
-    this.request.input.nluResolution = {
-      type: NluType.Keyword,
-      matchedValue: this.matchedKeyword,
-      payload: targetPayload,
-    }
-    await this.trackKeywordEvent()
-    return keywordNode
-  }
-
-  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
-        this.flowId = this.cmsApi.getNodeById<HtNodeWithContent>(
-          node.id
-        ).flow_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 { flowId, flowName, flowNodeId, flowNodeContentId } =
-      getCommonFlowContentEventArgsForContentId(
-        this.request,
-        this.keywordNodeId as string
-      )
-
-    const event: EventKeyword = {
-      action: EventAction.Keyword,
-      flowNodeId,
-      flowId,
-      flowName,
-      flowNodeContentId,
-      flowThreadId: this.request.session.flow_thread_id as string,
-      nluKeywordName: this.matchedKeyword as string,
-      nluKeywordIsRegex: this.isRegExp,
-      nluKeywordMessageId: this.request.input.message_id,
-      userInput: this.userTextOrTranscript,
-    }
-    const { action, ...eventArgs } = event
-    await trackEvent(this.request, action, eventArgs)
-  }
-}

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

@@ -1,119 +0,0 @@
-import { EventAction, type EventIntentSmart, NluType } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-import axios from 'axios'
-
-import type { FlowBuilderApi } from '../api'
-import type { HtSmartIntentNode } from '../content-fields/hubtype-fields/smart-intent'
-import { getFlowBuilderPlugin } from '../helpers'
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import type { SmartIntentResponse } from '../types'
-
-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,
-    public userTextOrTranscript: string
-  ) {}
-
-  async getNodeByInput(): Promise<HtSmartIntentNode | undefined> {
-    if (!this.userTextOrTranscript) {
-      return undefined
-    }
-    const smartIntentNodes = this.cmsApi.getSmartIntentNodes()
-    if (!smartIntentNodes.length) {
-      return undefined
-    }
-
-    const params = {
-      bot_id: this.currentRequest.session.bot.id,
-      text: this.userTextOrTranscript,
-      num_smart_intents_to_use: this.smartIntentsConfig.numSmartIntentsToUse,
-      use_latest: this.resolveUseLatest(),
-    }
-
-    try {
-      const response = await this.getInference(params)
-      const smartIntentNode = smartIntentNodes.find(
-        smartIntentNode =>
-          smartIntentNode.content.title === response.data.smart_intent_title
-      )
-
-      if (smartIntentNode) {
-        const targetPayload = this.cmsApi.getPayload(smartIntentNode.target)
-        this.currentRequest.input.nluResolution = {
-          type: NluType.SmartIntent,
-          matchedValue: smartIntentNode.content.title,
-          payload: targetPayload,
-        }
-
-        const { flowId, flowName, flowNodeId, flowNodeContentId } =
-          getCommonFlowContentEventArgsForContentId(
-            this.currentRequest,
-            smartIntentNode.id
-          )
-
-        const event: EventIntentSmart = {
-          action: EventAction.IntentSmart,
-          nluIntentSmartTitle: response.data.smart_intent_title,
-          nluIntentSmartNumUsed: response.data.smart_intents_used.length,
-          nluIntentSmartMessageId: this.currentRequest.input.message_id,
-          userInput: this.userTextOrTranscript,
-          flowThreadId: this.currentRequest.session.flow_thread_id as string,
-          flowId,
-          flowName,
-          flowNodeContentId,
-          flowNodeId,
-        }
-        const { action, ...eventArgs } = event
-
-        await trackEvent(this.currentRequest, action, eventArgs)
-
-        return smartIntentNode
-      }
-    } catch (e) {
-      console.error(e)
-    }
-    return undefined
-  }
-
-  private resolveUseLatest(): boolean {
-    if (this.currentRequest.session.is_test_integration) {
-      return false
-    }
-    return this.smartIntentsConfig.useLatest
-  }
-
-  private async getInference(
-    inferenceParams: SmartIntentsInferenceParams
-  ): Promise<SmartIntentResponse> {
-    const pluginFlowBuilder = getFlowBuilderPlugin(this.currentRequest.plugins)
-    const token = pluginFlowBuilder.getAccessToken(this.currentRequest.session)
-
-    return await axios({
-      method: 'POST',
-      url: `${process.env.HUBTYPE_API_URL}/external/v2/ai/smart_intents/inference/`,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        'Content-Type': 'application/json',
-      },
-      data: inferenceParams,
-      timeout: 10000,
-    })
-  }
-}

package/src/utils.ts

@@ -1,66 +0,0 @@
-import { INPUT, type Input, type Session } from '@botonic/core'
-import type { ActionRequest } from '@botonic/react'
-
-import { getFlowBuilderPlugin } from './helpers'
-import { type InShadowingConfig, ProcessEnvNodeEnvs } from './types'
-
-function getAccessTokenFromSession(session: Session): string {
-  if (!session._access_token) {
-    throw new Error('No access token found in session')
-  }
-  return session._access_token
-}
-
-export function resolveGetAccessToken(
-  getAccessToken: (session: Session) => string
-): (session: Session) => string {
-  switch (process.env.NODE_ENV) {
-    case ProcessEnvNodeEnvs.PRODUCTION:
-      return getAccessTokenFromSession
-    case ProcessEnvNodeEnvs.DEVELOPMENT:
-      return getAccessToken
-    default:
-      throw new Error('No method defined for getting access token')
-  }
-}
-
-export function inputHasTextOrTranscript(input: Input): boolean {
-  const isTextInput = Boolean(input.data) && input.type === INPUT.TEXT
-  const isTranscriptText =
-    Boolean(input.transcript) && input.type === INPUT.AUDIO
-
-  return isTextInput || isTranscriptText
-}
-
-export function getTextOrTranscript(input: Input): string | undefined {
-  if (input.type === INPUT.TEXT && input.data) {
-    return input.data
-  }
-  if (input.type === INPUT.AUDIO && input.transcript) {
-    return input.transcript
-  }
-
-  console.error('No text or transcript found in input', input)
-  return undefined
-}
-
-function isNluAllowed(
-  request: ActionRequest,
-  nluFlag: keyof InShadowingConfig
-): boolean {
-  const shadowing = Boolean(request.session._shadowing)
-  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
-  return !shadowing || (shadowing && flowBuilderPlugin.inShadowing[nluFlag])
-}
-
-export function isKeywordsAllowed(request: ActionRequest): boolean {
-  return isNluAllowed(request, 'allowKeywords')
-}
-
-export function isSmartIntentsAllowed(request: ActionRequest): boolean {
-  return isNluAllowed(request, 'allowSmartIntents')
-}
-
-export function isKnowledgeBasesAllowed(request: ActionRequest): boolean {
-  return isNluAllowed(request, 'allowKnowledgeBases')
-}

package/src/webview/contents-context.ts

@@ -1,11 +0,0 @@
-import { createContext } from 'react'
-
-import type { MapContentsType, WebviewContentsContextType } from './types'
-
-export const createWebviewContentsContext = <T extends MapContentsType>() =>
-  createContext<WebviewContentsContextType<T>>({
-    getTextContent: () => '',
-    getImageSrc: () => '',
-    setCurrentLocale: () => undefined,
-    contents: {} as Record<keyof T, string>,
-  })

package/src/webview/index.ts

@@ -1,3 +0,0 @@
-export { createWebviewContentsContext } from './contents-context'
-export * from './types'
-export { useWebviewContents } from './use-webview-contents'