@botonic/plugin-flow-builder 0.37.1 → 0.37.2-alpha.0

package/src/action/knowledge-bases.ts

@@ -1,4 +1,11 @@
-import { BotContext, ResolvedPlugins } from '@botonic/core'
+import {
+  BotContext,
+  EventAction,
+  EventKnowledgeBase,
+  KnowledgebaseFailReason,
+  KnowledgeBasesResponse,
+  ResolvedPlugins,
+} from '@botonic/core'
 
 import {
   DISABLED_MEMORY_LENGTH,
@@ -6,8 +13,9 @@ import {
   FlowKnowledgeBase,
 } from '../content-fields'
 import { HtNodeWithContent } from '../content-fields/hubtype-fields/nodes'
-import { EventAction, KnowledgebaseFailReason, trackEvent } from '../tracking'
-import { KnowledgeBaseFunction, KnowledgeBaseResponse } from '../types'
+import { getFlowBuilderPlugin } from '../helpers'
+import { trackEvent } from '../tracking'
+import { KnowledgeBaseFunction } from '../types'
 import { inputHasTextData, isKnowledgeBasesAllowed } from '../utils'
 import { FlowBuilderContext } from './index'
 
@@ -37,9 +45,6 @@ export async function getContentsByKnowledgeBase({
     }
 
     const sourceIds = knowledgeBaseContent.sourcesData.map(source => source.id)
-    const flowId = cmsApi.getNodeById<HtNodeWithContent>(
-      knowledgeBaseContent.id
-    ).flow_id
 
     if (
       flowBuilderPlugin.getKnowledgeBaseResponse &&
@@ -51,8 +56,7 @@ export async function getContentsByKnowledgeBase({
           flowBuilderPlugin.getKnowledgeBaseResponse,
           request,
           contents,
-          knowledgeBaseContent,
-          flowId
+          knowledgeBaseContent
         )
 
       if (contentsWithKnowledgeResponse) {
@@ -70,8 +74,7 @@ async function getContentsWithKnowledgeResponse<
   getKnowledgeBaseResponse: KnowledgeBaseFunction<T>,
   request: BotContext<T>,
   contents: FlowContent[],
-  knowledgeBaseContent: FlowKnowledgeBase,
-  flowId: string
+  knowledgeBaseContent: FlowKnowledgeBase
 ): Promise<FlowContent[] | undefined> {
   const sourceIds = knowledgeBaseContent.sourcesData.map(source => source.id)
   const instructions = knowledgeBaseContent.instructions
@@ -87,12 +90,7 @@ async function getContentsWithKnowledgeResponse<
     messageId,
     memoryLength
   )
-  await trackKnowledgeBase(
-    knowledgeBaseResponse,
-    request,
-    knowledgeBaseContent,
-    flowId
-  )
+  await trackKnowledgeBase(knowledgeBaseResponse, request, knowledgeBaseContent)
 
   if (
     !knowledgeBaseResponse.hasKnowledge ||
@@ -106,7 +104,7 @@ async function getContentsWithKnowledgeResponse<
 
 function updateContentsWithResponse(
   contents: FlowContent[],
-  response: KnowledgeBaseResponse
+  response: KnowledgeBasesResponse
 ): FlowContent[] {
   return contents.map(content => {
     if (content instanceof FlowKnowledgeBase) {
@@ -119,38 +117,44 @@ function updateContentsWithResponse(
 }
 
 async function trackKnowledgeBase(
-  response: KnowledgeBaseResponse,
+  response: KnowledgeBasesResponse,
   request: BotContext,
-  knowledgeBaseContent: FlowKnowledgeBase,
-  flowId: string
+  knowledgeBaseContent: FlowKnowledgeBase
 ) {
-  const sourceIds = knowledgeBaseContent.sourcesData.map(source => source.id)
-  const knowledgebaseInferenceId = response.inferenceId
-  const knowledgebaseSourcesIds = sourceIds
-  const knowledgebaseChunksIds = response.chunkIds
-  const knowledgebaseMessageId = request.input.message_id
-  const flowThreadId = request.session.flow_thread_id
-  const flowNodeId = knowledgeBaseContent.id
+  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
+  const flowId = flowBuilderPlugin.cmsApi.getNodeById<HtNodeWithContent>(
+    knowledgeBaseContent.id
+  ).flow_id
 
-  let knowledgebaseFailReason: KnowledgebaseFailReason | undefined
+  const getKnowledgeFailReason = (): KnowledgebaseFailReason | undefined => {
+    let knowledgebaseFailReason: KnowledgebaseFailReason | undefined
 
-  if (!response.isFaithful) {
-    knowledgebaseFailReason = KnowledgebaseFailReason.Hallucination
+    if (!response.isFaithful) {
+      knowledgebaseFailReason = KnowledgebaseFailReason.Hallucination
+    }
+
+    if (!response.hasKnowledge) {
+      knowledgebaseFailReason = KnowledgebaseFailReason.NoKnowledge
+    }
+    return knowledgebaseFailReason
   }
 
-  if (!response.hasKnowledge) {
-    knowledgebaseFailReason = KnowledgebaseFailReason.NoKnowledge
+  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: flowId,
+    flowNodeId: knowledgeBaseContent.id,
   }
 
-  await trackEvent(request, EventAction.Knowledgebase, {
-    knowledgebaseInferenceId,
-    knowledgebaseFailReason,
-    knowledgebaseSourcesIds,
-    knowledgebaseChunksIds,
-    knowledgebaseMessageId,
-    userInput: request.input.data,
-    flowThreadId,
-    flowId,
-    flowNodeId,
-  })
+  const { action, ...eventArgs } = event
+
+  await trackEvent(request, action, eventArgs)
 }

package/src/action/payload.ts

@@ -1,10 +1,10 @@
-import { storeCaseRating } from '@botonic/core'
+import { EventAction, EventFeedback, storeCaseRating } from '@botonic/core'
 import { v7 as uuid } from 'uuid'
 
 import { AGENT_RATING_PAYLOAD, SEPARATOR } from '../constants'
 import { FlowContent } from '../content-fields'
 import { HtNodeWithContent } from '../content-fields/hubtype-fields'
-import { EventAction, trackEvent } from '../tracking'
+import { trackEvent } from '../tracking'
 import { FlowBuilderContext } from './index'
 
 export async function getContentsByPayload(
@@ -45,7 +45,7 @@ async function resolveRatingPayload(
   const possibleValues = ratingNode.content.buttons.map(button => button.value)
 
   if (request.session._hubtype_case_id) {
-    const event = {
+    const event: EventFeedback = {
       action: EventAction.FeedbackCase,
       feedbackTargetId: request.session._hubtype_case_id,
       feedbackGroupId: uuid().toString(),

package/src/content-fields/flow-ai-agent.tsx

@@ -1,16 +1,17 @@
+import { AgenticOutputMessage } from '@botonic/core'
 import { Button, Carousel, Text } from '@botonic/react'
 
 import { SOURCE_INFO_SEPARATOR } from '../constants'
-import { AgenticOutputMessage } from '../types'
 import { ContentFieldsBase } from './content-fields-base'
 import { FlowElement } from './flow-element'
-import { HtAiAgentNode } from './hubtype-fields/ai-agent'
+import { HtAiAgentNode, HtInputGuardrailRule } from './hubtype-fields/ai-agent'
 
 export class FlowAiAgent extends ContentFieldsBase {
   public code: string = ''
   public name: string = ''
   public instructions: string = ''
   public activeTools?: { name: string }[]
+  public inputGuardrailRules: HtInputGuardrailRule[]
 
   public responses: AgenticOutputMessage[] = []
 
@@ -19,14 +20,15 @@ export class FlowAiAgent extends ContentFieldsBase {
     newAiAgent.name = component.content.name
     newAiAgent.instructions = component.content.instructions
     newAiAgent.activeTools = component.content.active_tools
-
+    newAiAgent.inputGuardrailRules =
+      component.content.input_guardrail_rules || []
     return newAiAgent
   }
 
   toBotonic(id: string): JSX.Element {
     return (
       <>
-        {this.responses.map(response => {
+        {this.responses.map((response: AgenticOutputMessage) => {
           if (response.type === 'text') {
             return <Text key={id}>{response.content.text}</Text>
           }

package/src/content-fields/hubtype-fields/ai-agent.ts

@@ -1,11 +1,18 @@
 import { HtBaseNode } from './common'
 import { HtNodeWithContentType } from './node-types'
 
+export interface HtInputGuardrailRule {
+  name: string
+  description: string
+  is_active: boolean
+}
+
 export interface HtAiAgentNode extends HtBaseNode {
   type: HtNodeWithContentType.AI_AGENT
   content: {
     name: string
     instructions: string
     active_tools?: { name: string }[]
+    input_guardrail_rules?: HtInputGuardrailRule[]
   }
 }

package/src/tracking.ts

@@ -1,3 +1,4 @@
+import { EventAction, EventFlow } from '@botonic/core'
 import { ActionRequest } from '@botonic/react'
 import { v7 as uuidv7 } from 'uuid'
 
@@ -8,20 +9,6 @@ import {
 } from './content-fields/hubtype-fields'
 import { getFlowBuilderPlugin } from './helpers'
 
-export enum EventAction {
-  FlowNode = 'flow_node',
-  Keyword = 'nlu_keyword',
-  IntentSmart = 'nlu_intent_smart',
-  Knowledgebase = 'knowledgebase',
-  Fallback = 'fallback',
-  FeedbackCase = 'feedback_case',
-}
-
-export enum KnowledgebaseFailReason {
-  NoKnowledge = 'no_knowledge',
-  Hallucination = 'hallucination',
-}
-
 export async function trackEvent(
   request: ActionRequest,
   eventAction: EventAction,
@@ -43,37 +30,29 @@ export async function trackFlowContent(
   for (const content of contents) {
     const nodeContent = cmsApi.getNodeById<HtNodeWithContent>(content.id)
     if (nodeContent.type !== HtNodeWithContentType.KNOWLEDGE_BASE) {
-      const eventArgs = getContentEventArgs(request, {
-        code: nodeContent.code,
-        flowId: nodeContent.flow_id,
-        flowName: flowBuilderPlugin.getFlowName(nodeContent.flow_id),
-        id: nodeContent.id,
-        isMeaningful: nodeContent.is_meaningful ?? false,
-      })
-      await trackEvent(request, EventAction.FlowNode, eventArgs)
+      const event = getContentEventArgs(request, nodeContent)
+      const { action, ...eventArgs } = event
+      await trackEvent(request, action, eventArgs)
     }
   }
 }
 
 function getContentEventArgs(
   request: ActionRequest,
-  contentInfo: {
-    code: string
-    flowId: string
-    flowName: string
-    id: string
-    isMeaningful: boolean
-  }
-) {
+  nodeContent: HtNodeWithContent
+): EventFlow {
+  const flowBuilderPlugin = getFlowBuilderPlugin(request.plugins)
+  const flowName = flowBuilderPlugin.getFlowName(nodeContent.flow_id)
   const flowThreadId = request.session.flow_thread_id ?? uuidv7()
   request.session.flow_thread_id = flowThreadId
 
   return {
+    action: EventAction.FlowNode,
     flowThreadId,
-    flowId: contentInfo.flowId,
-    flowName: contentInfo.flowName,
-    flowNodeId: contentInfo.id,
-    flowNodeContentId: contentInfo.code,
-    flowNodeIsMeaningful: contentInfo.isMeaningful,
+    flowId: nodeContent.flow_id,
+    flowName: flowName,
+    flowNodeId: nodeContent.id,
+    flowNodeContentId: nodeContent.code,
+    flowNodeIsMeaningful: nodeContent.is_meaningful ?? false,
   }
 }

package/src/types.ts

@@ -1,4 +1,14 @@
-import { BotContext, PluginPreRequest, ResolvedPlugins } from '@botonic/core'
+import {
+  AgenticOutputMessage,
+  BotContext,
+  CarouselMessage,
+  InferenceResponse,
+  KnowledgeBasesResponse,
+  PluginPreRequest,
+  ResolvedPlugins,
+  TextMessage,
+  TextWithButtonsMessage,
+} from '@botonic/core'
 
 import { FlowContent } from './content-fields'
 import { HtFlowBuilderData } from './content-fields/hubtype-fields'
@@ -45,7 +55,7 @@ export type KnowledgeBaseFunction<
   instructions: string,
   messageId: string,
   memoryLength: number
-) => Promise<KnowledgeBaseResponse>
+) => Promise<KnowledgeBasesResponse>
 
 export type AiAgentFunction<
   TPlugins extends ResolvedPlugins = ResolvedPlugins,
@@ -53,12 +63,18 @@ export type AiAgentFunction<
 > = (
   request: BotContext<TPlugins, TExtraData>,
   aiAgentArgs: AiAgentArgs
-) => Promise<AgenticOutputMessage[] | undefined>
+) => Promise<InferenceResponse>
+
+export interface GuardrailRule {
+  name: string
+  description: string
+}
 
 export interface AiAgentArgs {
   name: string
   instructions: string
   activeTools?: { name: string }[]
+  inputGuardrailRules?: GuardrailRule[]
 }
 export type ContentFilter<
   TPlugins extends ResolvedPlugins = ResolvedPlugins,
@@ -86,14 +102,6 @@ export enum FlowBuilderJSONVersion {
   LATEST = 'latest',
 }
 
-export interface KnowledgeBaseResponse {
-  inferenceId: string
-  hasKnowledge: boolean
-  isFaithful: boolean
-  chunkIds: string[]
-  answer: string
-}
-
 export interface SmartIntentResponse {
   data: {
     smart_intent_title: string
@@ -108,44 +116,3 @@ export interface SmartIntentResponse {
 export interface PayloadParamsBase {
   followUpContentID?: string
 }
-
-export interface OutputBaseMessage {
-  type: 'text' | 'textWithButtons' | 'carousel' | 'exit'
-}
-
-export interface TextMessage extends OutputBaseMessage {
-  type: 'text'
-  content: {
-    text: string
-  }
-}
-
-export interface TextWithButtonsMessage extends OutputBaseMessage {
-  type: 'textWithButtons'
-  content: {
-    text: string
-    buttons: string[]
-  }
-}
-
-export interface CarouselMessage extends OutputBaseMessage {
-  type: 'carousel'
-  content: {
-    elements: {
-      title: string
-      subtitle: string
-      image: string
-      button: { text: string; url: string }
-    }[]
-  }
-}
-
-export interface ExitMessage extends OutputBaseMessage {
-  type: 'exit'
-}
-
-export type AgenticOutputMessage =
-  | TextMessage
-  | TextWithButtonsMessage
-  | CarouselMessage
-  | ExitMessage

package/src/user-input/keyword.ts

@@ -1,4 +1,4 @@
-import { NluType } from '@botonic/core'
+import { EventAction, EventKeyword, NluType } from '@botonic/core'
 import { ActionRequest } from '@botonic/react'
 
 import { FlowBuilderApi } from '../api'
@@ -7,7 +7,7 @@ import {
   HtKeywordNode,
   HtNodeWithContent,
 } from '../content-fields/hubtype-fields'
-import { EventAction, trackEvent } from '../tracking'
+import { trackEvent } from '../tracking'
 
 interface KeywordProps {
   cmsApi: FlowBuilderApi
@@ -101,15 +101,17 @@ export class KeywordMatcher {
   }
 
   private async trackKeywordEvent() {
-    const eventArgs = {
-      nluKeywordName: this.matchedKeyword,
+    const event: EventKeyword = {
+      action: EventAction.Keyword,
+      flowThreadId: this.request.session.flow_thread_id as string,
+      flowNodeId: this.keywordNodeId as string,
+      flowId: this.flowId as string,
+      nluKeywordName: this.matchedKeyword as string,
       nluKeywordIsRegex: this.isRegExp,
       nluKeywordMessageId: this.request.input.message_id,
-      userInput: this.request.input.data,
-      flowThreadId: this.request.session.flow_thread_id,
-      flowId: this.flowId,
-      flowNodeId: this.keywordNodeId,
+      userInput: this.request.input.data as string,
     }
-    await trackEvent(this.request, EventAction.Keyword, eventArgs)
+    const { action, ...eventArgs } = event
+    await trackEvent(this.request, action, eventArgs)
   }
 }

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

@@ -1,11 +1,11 @@
-import { NluType } from '@botonic/core'
+import { EventAction, EventIntentSmart, NluType } from '@botonic/core'
 import { ActionRequest } from '@botonic/react'
 import axios from 'axios'
 
 import { FlowBuilderApi } from '../api'
 import { HtSmartIntentNode } from '../content-fields/hubtype-fields/smart-intent'
 import { getFlowBuilderPlugin } from '../helpers'
-import { EventAction, trackEvent } from '../tracking'
+import { trackEvent } from '../tracking'
 import { SmartIntentResponse } from '../types'
 
 export interface SmartIntentsInferenceParams {
@@ -55,15 +55,19 @@ export class SmartIntentsApi {
           payload: targetPayload,
         }
 
-        await trackEvent(this.currentRequest, EventAction.IntentSmart, {
+        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.currentRequest.input.data,
-          flowThreadId: this.currentRequest.session.flow_thread_id,
+          flowThreadId: this.currentRequest.session.flow_thread_id as string,
           flowId: smartIntentNode.flow_id,
           flowNodeId: smartIntentNode.id,
-        })
+        }
+        const { action, ...eventArgs } = event
+
+        await trackEvent(this.currentRequest, action, eventArgs)
 
         return smartIntentNode
       }