@botonic/plugin-ai-agents 0.45.0-alpha.1 → 0.46.0-alpha-3

package/src/index.ts

@@ -5,13 +5,18 @@ import type {
   ResolvedPlugins,
 } from '@botonic/core'
 import { tool } from '@openai/agents'
-
+import { v7 as uuidv7 } from 'uuid'
 import { AIAgentBuilder } from './agent-builder'
-import { isProd, MAX_MEMORY_LENGTH } from './constants'
+import {
+  DEFAULT_MAX_RETRIES,
+  DEFAULT_TIMEOUT_16_SECONDS,
+  isProd,
+  MAX_MEMORY_LENGTH,
+} from './constants'
 import { createDebugLogger, type DebugLogger } from './debug-logger'
-import { HubtypeApiClient } from './hubtype-api-client'
-import { setUpOpenAI } from './openai'
+import { LLMConfig } from './llm-config'
 import { AIAgentRunner } from './runner'
+import { HubtypeApiClient } from './services/hubtype-api-client'
 import type {
   AgenticInputMessage,
   Context,
@@ -32,11 +37,11 @@ export default class BotonicPluginAiAgents<
   private readonly messageHistoryApiVersion: MessageHistoryApiVersion
   private readonly memory: MemoryOptions
   private readonly logger: DebugLogger
+  private readonly timeout: number
+  private readonly maxRetries: number
   public toolDefinitions: CustomTool<TPlugins, TExtraData>[] = []
 
   constructor(options?: PluginAiAgentOptions<TPlugins, TExtraData>) {
-    setUpOpenAI(options?.maxRetries, options?.timeout)
-
     if (options?.messageHistoryApiVersion === 'v1' && options?.memory) {
       throw new Error(
         'Cannot use memory when messageHistoryApiVersion is "v1". ' +
@@ -48,6 +53,8 @@ export default class BotonicPluginAiAgents<
     this.toolDefinitions = options?.customTools || []
     this.messageHistoryApiVersion = options?.messageHistoryApiVersion ?? 'v2'
     this.memory = options?.memory ?? {}
+    this.timeout = options?.timeout ?? DEFAULT_TIMEOUT_16_SECONDS
+    this.maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES
     this.logger = createDebugLogger(options?.enableDebug ?? false)
 
     this.logger.logInitialConfig({
@@ -64,34 +71,59 @@ export default class BotonicPluginAiAgents<
   }
 
   async getInference(
-    request: BotContext<TPlugins, TExtraData>,
+    botContext: BotContext<TPlugins, TExtraData>,
     aiAgentArgs: AiAgentArgs
   ): Promise<InferenceResponse> {
     try {
-      const authToken = isProd ? request.session._access_token : this.authToken
+      const authToken = isProd
+        ? botContext.session._access_token
+        : this.authToken
       if (!authToken) {
         throw new Error('Auth token is required')
       }
 
+      const inferenceId = uuidv7()
+
+      // Create client for OpenAI/Azure OpenAI
+      const llmConfig = new LLMConfig(
+        this.maxRetries,
+        this.timeout,
+        aiAgentArgs.model,
+        aiAgentArgs.verbosity
+      )
+
+      // Build tools
       const tools = this.buildTools(
         aiAgentArgs.activeTools?.map(tool => tool.name) || []
       )
+
+      // Build agent
       const agent = new AIAgentBuilder<TPlugins, TExtraData>({
         name: aiAgentArgs.name,
         instructions: aiAgentArgs.instructions,
         tools: tools,
-        contactInfo: request.session.user.contact_info || [],
+        contactInfo: botContext.session.user.contact_info || [],
         inputGuardrailRules: aiAgentArgs.inputGuardrailRules || [],
         sourceIds: aiAgentArgs.sourceIds || [],
-        campaignsContext: request.input.context?.campaigns_v2,
+        campaignsContext: botContext.input.context?.campaigns_v2,
         logger: this.logger,
+        llmConfig,
+        guardrailTrackingContext: {
+          botId: botContext.session.bot.id,
+          isTest: botContext.session.is_test_integration,
+          authToken,
+          inferenceId,
+        },
       }).build()
 
+      // Get messages
       const messages = await this.getMessages(
-        request,
+        botContext,
         authToken,
         MAX_MEMORY_LENGTH
       )
+
+      // Build context
       const context: Context<TPlugins, TExtraData> = {
         authToken,
         sourceIds: aiAgentArgs.sourceIds || [],
@@ -101,16 +133,23 @@ export default class BotonicPluginAiAgents<
           chunksIds: [],
           chunkTexts: [],
         },
-        request,
+        request: botContext,
       }
 
+      // Log agent debug info
       this.logger.logAgentDebugInfo(
         aiAgentArgs,
         tools.map(t => t.name),
         messages
       )
 
-      const runner = new AIAgentRunner<TPlugins, TExtraData>(agent, this.logger)
+      // Run agent
+      const runner = new AIAgentRunner<TPlugins, TExtraData>(
+        agent,
+        llmConfig,
+        inferenceId,
+        this.logger
+      )
       return await runner.run(messages, context)
     } catch (error) {
       console.error('error plugin returns undefined', error)
@@ -127,7 +166,7 @@ export default class BotonicPluginAiAgents<
   }
 
   private async getMessages(
-    request: BotContext,
+    botContext: BotContext,
     authToken: string,
     memoryLength: number
   ): Promise<AgenticInputMessage[]> {
@@ -138,11 +177,11 @@ export default class BotonicPluginAiAgents<
     }
 
     if (this.messageHistoryApiVersion === 'v1') {
-      return await hubtypeClient.getMessages(request, memoryLength)
+      return await hubtypeClient.getMessages(botContext, memoryLength)
     }
 
     // Default to V2
-    const result = await hubtypeClient.getMessagesV2(request, {
+    const result = await hubtypeClient.getMessagesV2(botContext, {
       maxMessages: this.memory.maxMessages ?? memoryLength,
       includeToolCalls: this.memory.includeToolCalls ?? true,
       maxFullToolResults: this.memory.maxFullToolResults ?? 1,
@@ -166,4 +205,5 @@ export default class BotonicPluginAiAgents<
   }
 }
 
+export * from './bot-config-tools'
 export * from './types'

package/src/llm-config.ts

@@ -0,0 +1,96 @@
+import type { VerbosityLevel } from '@botonic/core'
+import {
+  type ModelProvider,
+  type ModelSettings,
+  OpenAIProvider,
+} from '@openai/agents'
+import OpenAI, { AzureOpenAI } from 'openai'
+import {
+  AZURE_OPENAI_API_BASE,
+  AZURE_OPENAI_API_KEY,
+  AZURE_OPENAI_API_VERSION,
+  isProd,
+  OPENAI_API_KEY,
+  OPENAI_MODEL,
+  OPENAI_PROVIDER,
+} from './constants'
+
+export class LLMConfig {
+  private readonly maxRetries: number
+  private readonly timeout: number
+  public readonly modelName: string
+  public readonly modelSettings: ModelSettings
+  public readonly modelProvider: ModelProvider
+
+  constructor(
+    maxRetries: number,
+    timeout: number,
+    modelName: string,
+    verbosity: VerbosityLevel
+  ) {
+    this.maxRetries = maxRetries
+    this.timeout = timeout
+    this.modelName = OPENAI_PROVIDER === 'openai' ? OPENAI_MODEL : modelName
+    this.modelProvider = this.getModelProvider()
+    this.modelSettings = this.getModelSettings(modelName, verbosity)
+  }
+
+  private getModelProvider(): ModelProvider {
+    const client = this.getClient()
+    return new OpenAIProvider({
+      openAIClient: client,
+      useResponses: false,
+    })
+  }
+
+  private getClient(): OpenAI | AzureOpenAI {
+    if (OPENAI_PROVIDER === 'openai') {
+      return this.getOpenAIClient()
+    }
+
+    return this.getAzureClient()
+  }
+
+  private getOpenAIClient(): OpenAI {
+    return new OpenAI({
+      apiKey: OPENAI_API_KEY,
+      timeout: this.timeout,
+      maxRetries: this.maxRetries,
+      dangerouslyAllowBrowser: !isProd,
+    })
+  }
+
+  private getAzureClient(): AzureOpenAI {
+    return new AzureOpenAI({
+      apiKey: AZURE_OPENAI_API_KEY,
+      apiVersion: AZURE_OPENAI_API_VERSION,
+      deployment: this.modelName,
+      baseURL: AZURE_OPENAI_API_BASE,
+      timeout: this.timeout,
+      maxRetries: this.maxRetries,
+      dangerouslyAllowBrowser: !isProd,
+    })
+  }
+
+  private getModelSettings(
+    model: string,
+    verbosity: VerbosityLevel
+  ): ModelSettings {
+    if (model.includes('gpt-5')) {
+      return {
+        reasoning: { effort: 'none' },
+        temperature: 1,
+        text: { verbosity },
+      }
+    }
+
+    if (model.includes('gpt-4')) {
+      return {
+        temperature: 0,
+        text: { verbosity: 'medium' },
+      }
+    }
+
+    throw new Error(`Unsupported model: ${model}`)
+  }
+}

package/src/runner.ts

@@ -7,15 +7,20 @@ import {
   InputGuardrailTripwireTriggered,
   Runner,
   RunToolCallItem,
+  RunToolCallOutputItem,
 } from '@openai/agents'
-
+import { AZURE_OPENAI_API_VERSION, isProd, OPENAI_PROVIDER } from './constants'
 import type { DebugLogger } from './debug-logger'
+import type { LLMConfig } from './llm-config'
+import { HubtypeApiClient } from './services/hubtype-api-client'
+import { TrackFeature, TrackProductName } from './services/types'
 import { retrieveKnowledge } from './tools'
 import type {
   AgenticInputMessage,
   AgenticOutputMessage,
   AIAgent,
   Context,
+  ResultRawResponse,
   RunResult,
 } from './types'
 
@@ -26,6 +31,9 @@ interface AIAgentRunnerResult {
     messages?: OutputMessage[]
   }
   newItems?: RunToolCallItem[]
+  rawResponses?: ResultRawResponse[]
+  // biome-ignore lint/suspicious/noExplicitAny: state is a complex internal type
+  state?: any
 }
 
 export class AIAgentRunner<
@@ -33,10 +41,19 @@ export class AIAgentRunner<
   TExtraData = any,
 > {
   private agent: AIAgent<TPlugins, TExtraData>
+  private llmConfig: LLMConfig
+  private inferenceId: string
   private logger: DebugLogger
 
-  constructor(agent: AIAgent<TPlugins, TExtraData>, logger: DebugLogger) {
+  constructor(
+    agent: AIAgent<TPlugins, TExtraData>,
+    openAiClient: LLMConfig,
+    inferenceId: string,
+    logger: DebugLogger
+  ) {
     this.agent = agent
+    this.llmConfig = openAiClient
+    this.inferenceId = inferenceId
     this.logger = logger
   }
 
@@ -46,11 +63,24 @@ export class AIAgentRunner<
   ): Promise<RunResult> {
     const startTime = Date.now()
 
-    this.logger.logRunnerStart()
+    this.logger.logRunnerStart(
+      this.llmConfig.modelName,
+      this.llmConfig.modelSettings
+    )
 
     try {
+      const modelProvider = this.llmConfig.modelProvider
+      const modelSettings = this.llmConfig.modelSettings
+
+      const hasRetrieveKnowledge = this.agent.tools.includes(retrieveKnowledge)
+      if (hasRetrieveKnowledge && OPENAI_PROVIDER === 'azure') {
+        modelSettings.toolChoice = retrieveKnowledge.name
+      }
+
       const runner = new Runner({
-        modelSettings: { temperature: 0 },
+        modelSettings,
+        modelProvider,
+        tracingDisabled: true,
       })
       // Type assertion to bypass strict type checking - the actual return type from runner.run()
       // doesn't perfectly match our interface, but the properties we access are compatible
@@ -58,6 +88,13 @@ export class AIAgentRunner<
         context,
       })) as AIAgentRunnerResult
 
+      const endTime = Date.now()
+
+      void this.sendLlmRunTracking(result, context, startTime, endTime)
+
+      const { _context, ...restResult } = result.state
+      console.log('Runner result:', restResult)
+
       const outputMessages = result.finalOutput?.messages || []
       const hasExit =
         outputMessages.length === 0 ||
@@ -105,15 +142,66 @@ export class AIAgentRunner<
     }
   }
 
+  private async sendLlmRunTracking(
+    result: AIAgentRunnerResult,
+    context: Context<TPlugins, TExtraData>,
+    startTime: number,
+    endTime: number
+  ): Promise<void> {
+    if (!isProd) {
+      return
+    }
+    const rawResponses = result.rawResponses ?? []
+    if (rawResponses.length === 0) {
+      return
+    }
+    const botId = context.request.session.bot.id
+    const isTest = context.request.session.is_test_integration
+    const totalDuration = endTime - startTime
+    const durationPerCall = Math.round(totalDuration / rawResponses.length)
+    const temperature =
+      (this.llmConfig.modelSettings.temperature as number | undefined) ?? 0
+    const apiVersion =
+      OPENAI_PROVIDER === 'azure' ? AZURE_OPENAI_API_VERSION : ''
+
+    const llmRuns = rawResponses.map(response => ({
+      inference_id: this.inferenceId,
+      is_test: isTest,
+      product_name: TrackProductName.AI_AGENT,
+      deployment_name: this.llmConfig.modelName,
+      model_name:
+        (response.providerData?.['model'] as string | undefined) ??
+        this.llmConfig.modelName,
+      feature: TrackFeature.AI_AGENT_RUN,
+      api_version: apiVersion,
+      num_prompt_tokens: response.usage.inputTokens,
+      num_completion_tokens: response.usage.outputTokens,
+      duration_in_milliseconds: durationPerCall,
+      temperature,
+      error: null,
+    }))
+
+    const client = new HubtypeApiClient(context.authToken)
+    await client.trackLlmRuns(botId, {
+      llm_runs: llmRuns,
+    })
+  }
+
   private getToolsExecuted(
     result,
     context: Context<TPlugins, TExtraData>
   ): ToolExecution[] {
+    const toolResultsByCallId = this.getToolResultsByCallId(result.newItems)
+
     return (
       result.newItems
         ?.filter(item => item instanceof RunToolCallItem)
         .map((item: RunToolCallItem) =>
-          this.getToolExecutionInfo(item as RunToolCallItem, context)
+          this.getToolExecutionInfo(
+            item as RunToolCallItem,
+            context,
+            toolResultsByCallId
+          )
         )
         .filter(
           (toolExecution: ToolExecution) => toolExecution.toolName !== ''
@@ -121,9 +209,44 @@ export class AIAgentRunner<
     )
   }
 
+  private getToolResultsByCallId(newItems: unknown[]): Map<string, string> {
+    const map = new Map<string, string>()
+    for (const item of newItems || []) {
+      if (!(item instanceof RunToolCallOutputItem)) {
+        continue
+      }
+      const rawItem = item.rawItem as {
+        callId?: string
+        output?: string | { type?: string; text?: string }
+      }
+      const callId = rawItem?.callId
+      const output = rawItem?.output
+      if (callId == null || output == null) {
+        continue
+      }
+      const text = this.extractToolResult(output)
+      if (text != null) {
+        map.set(callId, text)
+      }
+    }
+    return map
+  }
+
+  private extractToolResult(
+    output: string | { type?: string; text?: string }
+  ): string | undefined {
+    if (typeof output === 'string') {
+      return output
+    }
+    return output?.type === 'text' && typeof output?.text === 'string'
+      ? output.text
+      : undefined
+  }
+
   private getToolExecutionInfo(
     item: RunToolCallItem,
-    context: Context<TPlugins, TExtraData>
+    context: Context<TPlugins, TExtraData>,
+    toolResultsByCallId: Map<string, string>
   ): ToolExecution {
     if (item.rawItem.type !== 'function_call') {
       return {
@@ -133,20 +256,25 @@ export class AIAgentRunner<
     }
     const toolName = item.rawItem.name
     const toolArguments = this.getSafeToolArguments(item.rawItem.arguments)
+    const toolResults = item.rawItem.callId
+      ? toolResultsByCallId.get(item.rawItem.callId)
+      : undefined
+
+    const toolExecution: ToolExecution = {
+      toolName,
+      toolArguments,
+      toolResults,
+    }
 
     if (toolName === retrieveKnowledge.name) {
       return {
-        toolName,
-        toolArguments,
+        ...toolExecution,
         knowledgebaseSourcesIds: context.knowledgeUsed.sourceIds,
         knowledgebaseChunksIds: context.knowledgeUsed.chunksIds,
       }
     }
 
-    return {
-      toolName,
-      toolArguments,
-    }
+    return toolExecution
   }
 
   private getSafeToolArguments(rawToolArguments: string): Record<string, any> {

package/src/{hubtype-api-client.ts → services/hubtype-api-client.ts}

@@ -2,85 +2,19 @@
 import type { BotContext } from '@botonic/core'
 import axios from 'axios'
 
-import { HUBTYPE_API_URL } from './constants'
-import type { AgenticInputMessage, Chunk } from './types'
-
-interface HubtypeAssistantMessage {
-  role: 'assistant'
-  content: string
-}
-
-interface HubtypeUserMessage {
-  role: 'user'
-  content: string
-}
-
-type HubtypeMessage = HubtypeAssistantMessage | HubtypeUserMessage
-
-// V2 API Types
-interface HubtypeToolCall {
-  id: string
-  type: 'function'
-  function: {
-    name: string
-    arguments: string
-  }
-}
-
-interface HubtypeUserMessageV2 {
-  role: 'user'
-  content: string | null
-}
-
-interface HubtypeAssistantMessageV2 {
-  role: 'assistant'
-  content: string | null
-  tool_calls?: HubtypeToolCall[] | null
-}
-
-interface HubtypeToolMessageV2 {
-  role: 'tool'
-  content: string | null
-  tool_call_id: string
-}
-
-interface HubtypeSystemMessageV2 {
-  role: 'system'
-  content: string | null
-}
-
-type HubtypeMessageV2 =
-  | HubtypeUserMessageV2
-  | HubtypeAssistantMessageV2
-  | HubtypeToolMessageV2
-  | HubtypeSystemMessageV2
-
-interface MessageHistoryResponseV2 {
-  messages: HubtypeMessageV2[]
-  conversation_id: string | null
-  truncated: boolean
-}
-
-export interface GetMessagesV2Options {
-  maxMessages?: number
-  includeToolCalls?: boolean
-  maxFullToolResults?: number
-  debugMode?: boolean
-}
-
-export interface GetMessagesV2Result {
-  messages: AgenticInputMessage[]
-  conversationId: string | null
-  truncated: boolean
-}
-
-interface MessageHistoryV2Params {
-  last_message_id: string
-  max_messages?: number
-  include_tool_calls?: boolean
-  max_full_tool_results?: number
-  debug_mode?: boolean
-}
+import { HUBTYPE_API_URL } from '../constants'
+import type { AgenticInputMessage, Chunk } from '../types'
+import type {
+  GetMessagesV2Options,
+  GetMessagesV2Result,
+  HubtypeAssistantMessageV2,
+  HubtypeMessage,
+  HubtypeMessageV2,
+  HubtypeToolMessageV2,
+  MessageHistoryResponseV2,
+  MessageHistoryV2Params,
+  TrackLlmRunsData,
+} from './types'
 
 export class HubtypeApiClient {
   private readonly authToken: string
@@ -131,7 +65,7 @@ export class HubtypeApiClient {
   }
 
   async getMessages(
-    request: BotContext,
+    botContext: BotContext,
     maxMemoryLength: number
   ): Promise<AgenticInputMessage[]> {
     const url = `${HUBTYPE_API_URL}/external/v1/ai/agent/message_history/`
@@ -140,7 +74,7 @@ export class HubtypeApiClient {
       Authorization: `Bearer ${this.authToken}`,
     }
     const params = {
-      last_message_id: request.input.message_id,
+      last_message_id: botContext.input.message_id,
       num_messages: maxMemoryLength,
     }
 
@@ -158,7 +92,7 @@ export class HubtypeApiClient {
   }
 
   async getMessagesV2(
-    request: BotContext,
+    botContext: BotContext,
     options: GetMessagesV2Options = {}
   ): Promise<GetMessagesV2Result> {
     const url = `${HUBTYPE_API_URL}/external/v2/ai/agent/message_history/`
@@ -167,7 +101,7 @@ export class HubtypeApiClient {
       Authorization: `Bearer ${this.authToken}`,
     }
     const params: MessageHistoryV2Params = {
-      last_message_id: request.input.message_id,
+      last_message_id: botContext.input.message_id,
       ...(options.maxMessages !== undefined && {
         max_messages: options.maxMessages,
       }),
@@ -268,6 +202,20 @@ export class HubtypeApiClient {
     }
   }
 
+  async trackLlmRuns(botId: string, data: TrackLlmRunsData): Promise<void> {
+    // Not stop the bot execution if the tracking fails, just log the error
+    try {
+      const url = `${HUBTYPE_API_URL}/external/v2/conversational_apps/${botId}/track_llm_runs/`
+      const headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.authToken}`,
+      }
+      await axios.post(url, data, { headers })
+    } catch (error) {
+      console.error('Failed to track LLM runs:', error)
+    }
+  }
+
   private formatMessage(message: HubtypeMessage): AgenticInputMessage {
     if (message.role === 'user') {
       return {