@botonic/plugin-ai-agents 0.46.0 → 2.23.0

package/src/index.ts

@@ -1,209 +0,0 @@
-import type {
-  AiAgentArgs,
-  BotContext,
-  Plugin,
-  ResolvedPlugins,
-} from '@botonic/core'
-import { tool } from '@openai/agents'
-import { v7 as uuidv7 } from 'uuid'
-import { AIAgentBuilder } from './agent-builder'
-import {
-  DEFAULT_MAX_RETRIES,
-  DEFAULT_TIMEOUT_16_SECONDS,
-  isProd,
-  MAX_MEMORY_LENGTH,
-} from './constants'
-import { createDebugLogger, type DebugLogger } from './debug-logger'
-import { LLMConfig } from './llm-config'
-import { AIAgentRunner } from './runner'
-import { HubtypeApiClient } from './services/hubtype-api-client'
-import type {
-  AgenticInputMessage,
-  Context,
-  CustomTool,
-  InferenceResponse,
-  MemoryOptions,
-  MessageHistoryApiVersion,
-  PluginAiAgentOptions,
-  Tool,
-} from './types'
-
-export default class BotonicPluginAiAgents<
-  TPlugins extends ResolvedPlugins = ResolvedPlugins,
-  TExtraData = any,
-> implements Plugin
-{
-  private readonly authToken?: string
-  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>) {
-    if (options?.messageHistoryApiVersion === 'v1' && options?.memory) {
-      throw new Error(
-        'Cannot use memory when messageHistoryApiVersion is "v1". ' +
-          'Either set messageHistoryApiVersion to "v2" or remove memory.'
-      )
-    }
-
-    this.authToken = options?.authToken
-    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({
-      messageHistoryApiVersion: this.messageHistoryApiVersion,
-      maxRetries: options?.maxRetries ?? 2,
-      timeout: options?.timeout ?? 16000,
-      customToolNames: this.toolDefinitions.map(t => t.name),
-      memory: this.memory,
-    })
-  }
-
-  pre(): void {
-    return
-  }
-
-  async getInference(
-    botContext: BotContext<TPlugins, TExtraData>,
-    aiAgentArgs: AiAgentArgs
-  ): Promise<InferenceResponse> {
-    try {
-      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: botContext.session.user.contact_info || [],
-        inputGuardrailRules: aiAgentArgs.inputGuardrailRules || [],
-        sourceIds: aiAgentArgs.sourceIds || [],
-        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(
-        botContext,
-        authToken,
-        MAX_MEMORY_LENGTH
-      )
-
-      // Build context
-      const context: Context<TPlugins, TExtraData> = {
-        authToken,
-        sourceIds: aiAgentArgs.sourceIds || [],
-        knowledgeUsed: {
-          query: '',
-          sourceIds: [],
-          chunksIds: [],
-          chunkTexts: [],
-        },
-        request: botContext,
-      }
-
-      // Log agent debug info
-      this.logger.logAgentDebugInfo(
-        aiAgentArgs,
-        tools.map(t => t.name),
-        messages
-      )
-
-      // 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)
-      return {
-        messages: [],
-        toolsExecuted: [],
-        memoryLength: 0,
-        exit: true,
-        error: true,
-        inputGuardrailsTriggered: [],
-        outputGuardrailsTriggered: [],
-      }
-    }
-  }
-
-  private async getMessages(
-    botContext: BotContext,
-    authToken: string,
-    memoryLength: number
-  ): Promise<AgenticInputMessage[]> {
-    const hubtypeClient = new HubtypeApiClient(authToken)
-
-    if (!isProd) {
-      return await hubtypeClient.getLocalMessages(memoryLength)
-    }
-
-    if (this.messageHistoryApiVersion === 'v1') {
-      return await hubtypeClient.getMessages(botContext, memoryLength)
-    }
-
-    // Default to V2
-    const result = await hubtypeClient.getMessagesV2(botContext, {
-      maxMessages: this.memory.maxMessages ?? memoryLength,
-      includeToolCalls: this.memory.includeToolCalls ?? true,
-      maxFullToolResults: this.memory.maxFullToolResults ?? 1,
-      debugMode: this.memory.debugMode ?? false,
-    })
-    return result.messages
-  }
-
-  private buildTools(activeToolNames: string[]): Tool<TPlugins, TExtraData>[] {
-    const availableTools = this.toolDefinitions.filter(tool =>
-      activeToolNames.includes(tool.name)
-    )
-    return availableTools.map(toolDefinition => {
-      return tool<any, Context<TPlugins, TExtraData>, any>({
-        name: toolDefinition.name,
-        description: toolDefinition.description,
-        parameters: toolDefinition.schema,
-        execute: toolDefinition.func,
-      })
-    })
-  }
-}
-
-export * from './bot-config-tools'
-export * from './types'

package/src/llm-config.ts

@@ -1,96 +0,0 @@
-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

@@ -1,287 +0,0 @@
-import type {
-  OutputMessage,
-  ResolvedPlugins,
-  ToolExecution,
-} from '@botonic/core'
-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'
-
-// Minimal interface matching the properties we actually use from Runner.run() result
-// This bypasses strict type checking while maintaining type safety for accessed properties
-interface AIAgentRunnerResult {
-  finalOutput?: {
-    messages?: OutputMessage[]
-  }
-  newItems?: RunToolCallItem[]
-  rawResponses?: ResultRawResponse[]
-  // biome-ignore lint/suspicious/noExplicitAny: state is a complex internal type
-  state?: any
-}
-
-export class AIAgentRunner<
-  TPlugins extends ResolvedPlugins = ResolvedPlugins,
-  TExtraData = any,
-> {
-  private agent: AIAgent<TPlugins, TExtraData>
-  private llmConfig: LLMConfig
-  private inferenceId: string
-  private 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
-  }
-
-  async run(
-    messages: AgenticInputMessage[],
-    context: Context<TPlugins, TExtraData>
-  ): Promise<RunResult> {
-    const startTime = Date.now()
-
-    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,
-        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
-      const result = (await runner.run(this.agent, messages, {
-        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 ||
-        outputMessages.some(message => message.type === 'exit')
-      const toolsExecuted = this.getToolsExecuted(result, context)
-
-      const runResult: RunResult = {
-        messages: hasExit
-          ? []
-          : (outputMessages.filter(
-              message => message.type !== 'exit'
-            ) as AgenticOutputMessage[]),
-        toolsExecuted,
-        exit: hasExit,
-        memoryLength: messages.length,
-        error: false,
-        inputGuardrailsTriggered: [],
-        outputGuardrailsTriggered: [],
-      }
-
-      this.logger.logRunResult(runResult, startTime)
-
-      return runResult
-    } catch (error) {
-      if (error instanceof InputGuardrailTripwireTriggered) {
-        const runResult: RunResult = {
-          messages: [],
-          memoryLength: 0,
-          toolsExecuted: [],
-          exit: true,
-          error: false,
-          inputGuardrailsTriggered: error.result.output.outputInfo,
-          outputGuardrailsTriggered: [],
-        }
-
-        this.logger.logGuardrailTriggered()
-        this.logger.logRunResult(runResult, startTime)
-
-        return runResult
-      }
-
-      this.logger.logRunnerError(startTime, error)
-
-      throw error
-    }
-  }
-
-  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,
-            toolResultsByCallId
-          )
-        )
-        .filter(
-          (toolExecution: ToolExecution) => toolExecution.toolName !== ''
-        ) || []
-    )
-  }
-
-  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>,
-    toolResultsByCallId: Map<string, string>
-  ): ToolExecution {
-    if (item.rawItem.type !== 'function_call') {
-      return {
-        toolName: '',
-        toolArguments: {},
-      }
-    }
-    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 {
-        ...toolExecution,
-        knowledgebaseSourcesIds: context.knowledgeUsed.sourceIds,
-        knowledgebaseChunksIds: context.knowledgeUsed.chunksIds,
-      }
-    }
-
-    return toolExecution
-  }
-
-  private getSafeToolArguments(rawToolArguments: string): Record<string, any> {
-    try {
-      return JSON.parse(rawToolArguments)
-    } catch (_error) {
-      return {}
-    }
-  }
-}