@botonic/plugin-flow-builder 0.46.2 → 2.23.0

package/src/action/knowledge-bases.ts

@@ -1,161 +0,0 @@
-import {
-  type BotContext,
-  EventAction,
-  type EventKnowledgeBase,
-  type KnowledgeBasesResponse,
-  KnowledgebaseFailReason,
-  type ResolvedPlugins,
-} from '@botonic/core'
-
-import {
-  DISABLED_MEMORY_LENGTH,
-  type FlowContent,
-  FlowKnowledgeBase,
-} from '../content-fields'
-import {
-  getCommonFlowContentEventArgsForContentId,
-  trackEvent,
-} from '../tracking'
-import type { KnowledgeBaseFunction } from '../types'
-import { inputHasTextOrTranscript, isKnowledgeBasesAllowed } from '../utils'
-import type { FlowBuilderContext } from './index'
-
-export async function getContentsByKnowledgeBase({
-  cmsApi,
-  flowBuilderPlugin,
-  request,
-}: FlowBuilderContext): Promise<FlowContent[]> {
-  if (isKnowledgeBasesAllowed(request)) {
-    const startNodeKnowledgeBaseFlow = cmsApi.getStartNodeKnowledgeBaseFlow()
-    const isKnowledgeBaseEnabled = cmsApi.isKnowledgeBaseEnabled()
-
-    if (!startNodeKnowledgeBaseFlow || !isKnowledgeBaseEnabled) {
-      return []
-    }
-
-    const contents = await flowBuilderPlugin.getContentsByNode(
-      startNodeKnowledgeBaseFlow
-    )
-
-    const knowledgeBaseContent = contents.find(
-      content => content instanceof FlowKnowledgeBase
-    ) as FlowKnowledgeBase
-
-    if (!knowledgeBaseContent) {
-      return contents
-    }
-
-    const sourceIds = knowledgeBaseContent.sourcesData.map(source => source.id)
-
-    if (
-      flowBuilderPlugin.getKnowledgeBaseResponse &&
-      inputHasTextOrTranscript(request.input) &&
-      sourceIds.length > 0
-    ) {
-      const contentsWithKnowledgeResponse =
-        await getContentsWithKnowledgeResponse(
-          flowBuilderPlugin.getKnowledgeBaseResponse,
-          request,
-          contents,
-          knowledgeBaseContent
-        )
-
-      if (contentsWithKnowledgeResponse) {
-        return contentsWithKnowledgeResponse
-      }
-    }
-  }
-
-  return []
-}
-
-async function getContentsWithKnowledgeResponse<
-  T extends ResolvedPlugins = ResolvedPlugins,
->(
-  getKnowledgeBaseResponse: KnowledgeBaseFunction<T>,
-  request: BotContext<T>,
-  contents: FlowContent[],
-  knowledgeBaseContent: FlowKnowledgeBase
-): Promise<FlowContent[] | undefined> {
-  const sourceIds = knowledgeBaseContent.sourcesData.map(source => source.id)
-  const instructions = knowledgeBaseContent.instructions
-  const messageId = request.input.message_id
-  const memoryLength = knowledgeBaseContent.hasMemory
-    ? knowledgeBaseContent.memoryLength
-    : DISABLED_MEMORY_LENGTH
-
-  const knowledgeBaseResponse = await getKnowledgeBaseResponse(
-    request,
-    sourceIds,
-    instructions,
-    messageId,
-    memoryLength
-  )
-  await trackKnowledgeBase(knowledgeBaseResponse, request, knowledgeBaseContent)
-
-  if (
-    !knowledgeBaseResponse.hasKnowledge ||
-    !knowledgeBaseResponse.isFaithful
-  ) {
-    return undefined
-  }
-
-  return updateContentsWithResponse(contents, knowledgeBaseResponse)
-}
-
-function updateContentsWithResponse(
-  contents: FlowContent[],
-  response: KnowledgeBasesResponse
-): FlowContent[] {
-  return contents.map(content => {
-    if (content instanceof FlowKnowledgeBase) {
-      content.text = response.answer
-      content.inferenceId = response.inferenceId
-    }
-
-    return content
-  })
-}
-
-async function trackKnowledgeBase(
-  response: KnowledgeBasesResponse,
-  request: BotContext,
-  knowledgeBaseContent: FlowKnowledgeBase
-) {
-  const getKnowledgeFailReason = (): KnowledgebaseFailReason | undefined => {
-    let knowledgebaseFailReason: KnowledgebaseFailReason | undefined
-
-    if (!response.isFaithful) {
-      knowledgebaseFailReason = KnowledgebaseFailReason.Hallucination
-    }
-
-    if (!response.hasKnowledge) {
-      knowledgebaseFailReason = KnowledgebaseFailReason.NoKnowledge
-    }
-    return knowledgebaseFailReason
-  }
-
-  const { flowId, flowName, flowNodeId, flowNodeContentId } =
-    getCommonFlowContentEventArgsForContentId(request, knowledgeBaseContent.id)
-
-  const event: EventKnowledgeBase = {
-    action: EventAction.Knowledgebase,
-    knowledgebaseInferenceId: response.inferenceId,
-    knowledgebaseFailReason: getKnowledgeFailReason(),
-    knowledgebaseSourcesIds: knowledgeBaseContent.sourcesData.map(
-      source => source.id
-    ),
-    knowledgebaseChunksIds: response.chunkIds,
-    knowledgebaseMessageId: request.input.message_id,
-    userInput: request.input.data as string,
-    flowThreadId: request.session.flow_thread_id as string,
-    flowId,
-    flowName,
-    flowNodeId,
-    flowNodeContentId,
-  }
-
-  const { action, ...eventArgs } = event
-
-  await trackEvent(request, action, eventArgs)
-}

package/src/action/payload.ts

@@ -1,104 +0,0 @@
-import { EventAction, type EventFeedback, storeCaseRating } from '@botonic/core'
-import { v7 as uuid } from 'uuid'
-
-import {
-  AGENT_RATING_PAYLOAD,
-  PUSH_FLOW_PAYLOAD,
-  SEPARATOR,
-} from '../constants'
-import type { FlowContent } from '../content-fields'
-import type { HtNodeWithContent } from '../content-fields/hubtype-fields'
-import { trackEvent } from '../tracking'
-import type { FlowBuilderContext } from './index'
-
-export async function getContentsByPayload(
-  context: FlowBuilderContext
-): Promise<FlowContent[]> {
-  const { cmsApi, flowBuilderPlugin, request, contentID } = context
-  if (request.input.payload?.startsWith(AGENT_RATING_PAYLOAD)) {
-    return await resolveRatingPayload(context)
-  }
-  if (request.input.payload?.startsWith(PUSH_FLOW_PAYLOAD)) {
-    return await resolvePushFlowPayload(context)
-  }
-
-  const id = contentID
-    ? cmsApi.getNodeByContentID(contentID)?.id
-    : request.input.payload
-  const targetNode = id ? cmsApi.getNodeById<HtNodeWithContent>(id) : undefined
-
-  if (targetNode) {
-    return await flowBuilderPlugin.getContentsByNode(targetNode)
-  }
-
-  return []
-}
-
-async function resolveRatingPayload(
-  context: FlowBuilderContext
-): Promise<FlowContent[]> {
-  const { cmsApi, flowBuilderPlugin, request } = context
-
-  if (!request.input.payload) {
-    return []
-  }
-
-  const { target, text, value, possibleOptions, possibleValues } =
-    flowBuilderPlugin.getRatingSubmittedInfo(request.input.payload)
-
-  if (request.session._hubtype_case_id) {
-    const event: EventFeedback = {
-      action: EventAction.FeedbackCase,
-      feedbackTargetId: request.session._hubtype_case_id,
-      feedbackGroupId: uuid().toString(),
-      possibleOptions,
-      possibleValues,
-      option: text,
-      value,
-    }
-
-    await storeCaseRating(request.session, value)
-    await trackEvent(request, EventAction.FeedbackCase, event)
-  }
-
-  const targetNode = target
-    ? cmsApi.getNodeById<HtNodeWithContent>(target.id)
-    : undefined
-
-  if (targetNode) {
-    return await flowBuilderPlugin.getContentsByNode(targetNode)
-  }
-
-  return []
-}
-
-async function resolvePushFlowPayload(
-  context: FlowBuilderContext
-): Promise<FlowContent[]> {
-  const { cmsApi, flowBuilderPlugin, request } = context
-
-  if (!request.input.payload) {
-    return []
-  }
-
-  const parts = request.input.payload.split(SEPARATOR)
-  const pushFlowId = parts.length > 1 ? parts[1] : ''
-
-  if (!pushFlowId) {
-    return []
-  }
-
-  try {
-    const pushFlowNode =
-      cmsApi.getNodeByCampaignId<HtNodeWithContent>(pushFlowId)
-
-    if (!pushFlowNode) {
-      return []
-    }
-
-    return await flowBuilderPlugin.getContentsByNode(pushFlowNode)
-  } catch {
-    // Campaign not found - return empty to trigger fallback
-    return []
-  }
-}

package/src/api.ts

@@ -1,364 +0,0 @@
-import type { PluginPreRequest } from '@botonic/core'
-import axios from 'axios'
-
-import {
-  AI_AGENTS_FLOW_NAME,
-  KNOWLEDGE_BASE_FLOW_NAME,
-  SEPARATOR,
-  UUID_REGEXP,
-} from './constants'
-import {
-  type HtBotActionNode,
-  type HtCaptureUserInputNode,
-  type HtFallbackNode,
-  type HtFlowBuilderData,
-  type HtFlowWebview,
-  type HtGoToFlow,
-  type HtKeywordNode,
-  type HtNodeComponent,
-  type HtNodeLink,
-  type HtNodeWithContent,
-  HtNodeWithContentType,
-  type HtPayloadNode,
-  type HtRatingButton,
-  type HtRatingNode,
-  type HtSmartIntentNode,
-} from './content-fields/hubtype-fields'
-import { type FlowBuilderApiOptions, ProcessEnvNodeEnvs } from './types'
-
-export class FlowBuilderApi {
-  url: string
-  flowUrl: string
-  flow: HtFlowBuilderData
-  request: PluginPreRequest
-
-  private constructor() {}
-
-  static async create(options: FlowBuilderApiOptions): Promise<FlowBuilderApi> {
-    const newApi = new FlowBuilderApi()
-
-    newApi.url = options.url
-    newApi.request = options.request
-    // TODO: Refactor later to combine logic from `FlowBuilderApi.create`, `resolveFlowUrl` and `getAccessToken` to be in one place
-    if (process.env.NODE_ENV === ProcessEnvNodeEnvs.DEVELOPMENT) {
-      await newApi.updateSessionWithUserInfo(options.accessToken)
-    }
-    const updatedRequest = newApi.request
-    newApi.flowUrl = options.flowUrl.replace(
-      '{bot_id}',
-      updatedRequest.session.bot.id
-    )
-    newApi.flow = options.flow ?? (await newApi.getFlow(options.accessToken))
-    return newApi
-  }
-
-  private async getFlow(token: string): Promise<HtFlowBuilderData> {
-    const { data } = await axios.get(this.flowUrl, {
-      headers: { Authorization: `Bearer ${token}` },
-    })
-    return data as HtFlowBuilderData
-  }
-
-  private async updateSessionWithUserInfo(token: string) {
-    const url = `${this.url}/v1/flow_builder/user_info/`
-    const response = await axios.get(url, {
-      headers: { Authorization: `Bearer ${token}` },
-    })
-    this.request.session.organization_id = response.data.organization_id
-    this.request.session.bot.id = response.data.bot_id
-  }
-
-  getNodeByFlowId(id: string): HtNodeWithContent {
-    const subFlow = this.flow.flows.find(subFlow => subFlow.id === id)
-    if (!subFlow) {
-      throw Error(`SubFlow with id: '${id}' not found`)
-    }
-    return this.getNodeById<HtNodeWithContent>(subFlow.start_node_id)
-  }
-
-  getNodeByCampaignId<T extends HtNodeComponent>(id: string): T {
-    const campaign = this.flow.campaigns.find(campaign => campaign.id === id)
-    if (!campaign) {
-      throw Error(`Campaign with id: '${id}' not found`)
-    }
-    return this.getNodeById<T>(campaign.start_node_id)
-  }
-
-  getNodeById<T extends HtNodeComponent>(id: string): T {
-    const node = this.flow.nodes.find(node => node.id === id)
-    if (!node) {
-      console.error(`Node with id: '${id}' not found`)
-    }
-
-    return node as T
-  }
-
-  getRatingNodeByButtonId(id: string): HtRatingNode {
-    const ratingNodes = this.flow.nodes.filter(
-      node => node.type === HtNodeWithContentType.RATING
-    ) as HtRatingNode[]
-    const ratingNode = ratingNodes.find(node =>
-      node.content.buttons.some(button => button.id === id)
-    ) as HtRatingNode | undefined
-
-    if (!ratingNode) {
-      throw Error(`Rating node with button id: '${id}' not found`)
-    }
-
-    return ratingNode
-  }
-
-  getRatingButtonById(ratingNode: HtRatingNode, id: string): HtRatingButton {
-    const ratingButton = ratingNode.content.buttons.find(
-      button => button.id === id
-    ) as HtRatingButton | undefined
-    if (!ratingButton) {
-      throw Error(`Rating button with id: '${id}' not found`)
-    }
-
-    return ratingButton
-  }
-
-  getNodeByContentID(contentID: string): HtNodeComponent {
-    const content = this.flow.nodes.find(node =>
-      'code' in node ? node.code === contentID : false
-    )
-    if (!content) {
-      throw Error(`Node with contentID: '${contentID}' not found`)
-    }
-    return content
-  }
-
-  getStartNode(): HtNodeWithContent {
-    const startNodeId = this.flow.start_node_id
-    if (!startNodeId) {
-      throw new Error('Start node id must be defined')
-    }
-    return this.getNodeById(startNodeId)
-  }
-
-  getFallbackNode(alternate: boolean): HtNodeWithContent {
-    const fallbackNode = this.flow.nodes.find(
-      node => node.type === HtNodeWithContentType.FALLBACK
-    ) as HtFallbackNode | undefined
-    if (!fallbackNode) {
-      throw new Error('Fallback node must be defined')
-    }
-    const fallbackFirstMessage = fallbackNode.content.first_message
-    if (!fallbackFirstMessage) {
-      throw new Error('Fallback 1st message must be defined')
-    }
-    const fallbackSecondMessage = fallbackNode.content.second_message
-    if (!fallbackSecondMessage) {
-      return this.getNodeById(fallbackFirstMessage.id)
-    }
-    return alternate
-      ? this.getNodeById(fallbackFirstMessage.id)
-      : this.getNodeById(fallbackSecondMessage.id)
-  }
-
-  getKnowledgeBaseConfig():
-    | { followup?: HtNodeLink; isActive: boolean }
-    | undefined {
-    const fallbackNode = this.flow.nodes.find(
-      node => node.type === HtNodeWithContentType.FALLBACK
-    ) as HtFallbackNode | undefined
-
-    return fallbackNode
-      ? {
-          followup: fallbackNode.content.knowledge_base_followup,
-          isActive: fallbackNode.content.is_knowledge_base_active || false,
-        }
-      : undefined
-  }
-
-  getSmartIntentNodes(): HtSmartIntentNode[] {
-    return this.flow.nodes.filter(
-      node => node.type === HtNodeWithContentType.SMART_INTENT
-    ) as HtSmartIntentNode[]
-  }
-
-  getKeywordNodes(): HtKeywordNode[] {
-    return this.flow.nodes.filter(
-      node => node.type === HtNodeWithContentType.KEYWORD
-    ) as HtKeywordNode[]
-  }
-
-  getPayload(target?: HtNodeLink): string | undefined {
-    if (!target) {
-      return undefined
-    }
-
-    return target.id
-  }
-
-  isBotAction(id: string): boolean {
-    if (!this.isUUID(id)) {
-      return false
-    }
-    const node = this.getNodeById(id)
-    return node?.type === HtNodeWithContentType.BOT_ACTION
-  }
-
-  private isUUID(str: string): boolean {
-    return UUID_REGEXP.test(str)
-  }
-
-  isGoToFlow(id: string): boolean {
-    if (!this.isUUID(id)) {
-      return false
-    }
-    const node = this.getNodeById(id)
-    return node?.type === HtNodeWithContentType.GO_TO_FLOW
-  }
-
-  createPayloadWithParams(botActionNode: HtBotActionNode): string {
-    const payloadId = botActionNode.content.payload_id
-    const payloadNode = this.getNodeById<HtPayloadNode>(payloadId)
-    const customParams = JSON.parse(
-      botActionNode.content.payload_params || '{}'
-    )
-
-    const followUpContentID = this.getFollowUpContentID(
-      botActionNode.follow_up?.id
-    )
-
-    const payloadJson = JSON.stringify({
-      ...customParams,
-      followUpContentID,
-    })
-    return `${payloadNode.content.payload}${SEPARATOR}${payloadJson}`
-  }
-
-  private getFollowUpContentID(id?: string): string | undefined {
-    const followUpNode = id
-      ? this.getNodeById<HtNodeWithContent | HtGoToFlow>(id)
-      : undefined
-
-    return followUpNode?.code
-  }
-
-  getFlowName(flowId: string): string {
-    const flow = this.flow.flows.find(flow => flow.id === flowId)
-    return flow ? flow.name : this.getCampaignFlowName(flowId)
-  }
-
-  getCampaignFlowName(campaignId: string): string {
-    const campaign = this.flow.campaigns.find(
-      campaign => campaign.id === campaignId
-    )
-    return campaign ? campaign.name : ''
-  }
-
-  getStartNodeKnowledgeBaseFlow(): HtNodeWithContent | undefined {
-    const knowledgeBaseFlow = this.flow.flows.find(
-      flow => flow.name === KNOWLEDGE_BASE_FLOW_NAME
-    )
-    if (!knowledgeBaseFlow) {
-      return undefined
-    }
-    return this.getNodeById<HtNodeWithContent>(knowledgeBaseFlow.start_node_id)
-  }
-
-  getStartNodeAiAgentFlow(): HtNodeWithContent | undefined {
-    const aiAgentFlow = this.flow.flows.find(
-      flow => flow.name === AI_AGENTS_FLOW_NAME
-    )
-
-    if (!aiAgentFlow) {
-      return undefined
-    }
-
-    return this.getNodeById<HtNodeWithContent>(aiAgentFlow.start_node_id)
-  }
-
-  isKnowledgeBaseEnabled(): boolean {
-    return this.flow.is_knowledge_base_active || false
-  }
-
-  isAiAgentEnabled(): boolean {
-    return this.flow.is_ai_agent_active || false
-  }
-
-  getWebviewById(id: string): HtFlowWebview | undefined {
-    return this.flow.webviews.find(webview => webview.id === id)
-  }
-
-  shouldCaptureUserInput(): boolean {
-    return !!this.getCaptureUserInputId()
-  }
-
-  getCaptureUserInputId(): string | undefined {
-    return this.request.session.capture_user_input?.node_id
-  }
-
-  setCaptureUserInputId(id: string): void {
-    if (this.request.session.capture_user_input) {
-      this.request.session.capture_user_input.node_id = id
-    }
-    this.request.session.capture_user_input = { node_id: id }
-  }
-
-  removeCaptureUserInputId(): void {
-    this.request.session.capture_user_input = undefined
-  }
-
-  setUserExtraDataVariable(key: string, value: string): void {
-    if (this.request.session.user.extra_data) {
-      this.request.session.user.extra_data[key] = value
-    }
-  }
-
-  getCaptureUserInputNode(): HtCaptureUserInputNode | undefined {
-    const captureUserInputId = this.getCaptureUserInputId()
-    if (!captureUserInputId) {
-      return undefined
-    }
-    return this.getNodeById<HtCaptureUserInputNode>(captureUserInputId)
-  }
-
-  getResolvedLocale(): string {
-    const systemLocale = this.request.getSystemLocale()
-
-    const locale = this.resolveAsLocale(systemLocale)
-    if (locale) {
-      return locale
-    }
-
-    const language = this.resolveAsLanguage(systemLocale)
-    if (language) {
-      this.request.setSystemLocale(language)
-      return language
-    }
-
-    const defaultLocale = this.resolveAsDefaultLocale()
-    this.request.setSystemLocale(defaultLocale)
-    return defaultLocale
-  }
-
-  private resolveAsLocale(locale: string): string | undefined {
-    if (this.flow.locales.find(flowLocale => flowLocale === locale)) {
-      return locale
-    }
-    return undefined
-  }
-
-  private resolveAsLanguage(locale?: string): string | undefined {
-    const language = locale?.split('-')[0]
-    if (
-      language &&
-      this.flow.locales.find(flowLocale => flowLocale === language)
-    ) {
-      console.log(`locale: ${locale} has been resolved as ${language}`)
-      return language
-    }
-    return undefined
-  }
-
-  private resolveAsDefaultLocale(): string {
-    console.log(
-      `Resolve locale with default locale: ${this.flow.default_locale_code}`
-    )
-    return this.flow.default_locale_code || 'en'
-  }
-}

package/src/constants.ts

@@ -1,20 +0,0 @@
-export const FLOW_BUILDER_API_URL_PROD =
-  process.env.HUBTYPE_API_URL || 'https://api.hubtype.com'
-export const SEPARATOR = '|'
-export const SOURCE_INFO_SEPARATOR = `${SEPARATOR}source_`
-export const EMPTY_PAYLOAD = 'fb-empty-payload'
-export const VARIABLE_PATTERN_GLOBAL = /{([^}]+)}/g
-export const ACCESS_TOKEN_VARIABLE_KEY = '_access_token'
-export const REG_EXP_PATTERN = /^\/(.*)\/([gimyus]*)$/
-export const UUID_REGEXP =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
-
-/* ********** PAYLOADS ********** */
-export const AGENT_RATING_PAYLOAD = 'agent-rating'
-export const PUSH_FLOW_PAYLOAD = 'push-flow'
-
-/* ********** FLOW NAMES ********** */
-export const MAIN_FLOW_NAME = 'Main'
-export const KNOWLEDGE_BASE_FLOW_NAME = 'Knowledge base'
-export const AI_AGENTS_FLOW_NAME = 'AI Agents'
-export const FALLBACK_FLOW_NAME = 'Fallback'