@botonic/plugin-ai-agents 0.49.0-alpha.3 → 0.49.0-alpha.5

package/src/constants.ts

@@ -1,11 +1,21 @@
 export const HUBTYPE_API_URL =
   process.env.HUBTYPE_API_URL || 'https://api.hubtype.com'
 
-// Azure OpenAI Configuration (used as local-dev fallback; production values come from BotSettings/BotSecrets)
-export const AZURE_OPENAI_API_KEY = process.env.AZURE_OPENAI_API_KEY // pragma: allowlist secret
-export const AZURE_OPENAI_API_BASE = process.env.AZURE_OPENAI_API_BASE
-export const AZURE_OPENAI_API_VERSION =
-  process.env.AZURE_OPENAI_API_VERSION || '2025-01-01-preview'
+// LLM Configuration (provider-agnostic; set LLM_PROVIDER=azure|openai)
+export const LLM_PROVIDERS = {
+  AZURE: 'azure',
+  OPENAI: 'openai',
+} as const
+
+export type LLMProviderType = (typeof LLM_PROVIDERS)[keyof typeof LLM_PROVIDERS]
+
+export const LLM_PROVIDER: LLMProviderType =
+  (process.env.LLM_PROVIDER as LLMProviderType) || LLM_PROVIDERS.AZURE
+export const LLM_API_KEY = process.env.LLM_API_KEY // pragma: allowlist secret
+export const LLM_API_URL = process.env.LLM_API_URL
+export const LLM_AZURE_API_VERSION =
+  process.env.LLM_AZURE_API_VERSION || '2025-01-01-preview'
+export const LLM_OPENAI_MODEL = process.env.LLM_OPENAI_MODEL || 'gpt-4.1-mini'
 
 export const isProd = process.env.NODE_ENV === 'production'
 
@@ -13,14 +23,3 @@ export const MAX_MEMORY_LENGTH = 25
 
 export const DEFAULT_TIMEOUT_16_SECONDS = 16000
 export const DEFAULT_MAX_RETRIES = 2
-
-export const LLM_PROVIDERS = {
-  LITELLM: 'litellm',
-  AZURE: 'azure',
-} as const
-
-export const LITELLM_TAG_KEYS = {
-  BOT_ID: 'bot_id',
-  ORG_ID: 'org_id',
-  SEPARATOR: ',',
-} as const

package/src/debug-logger.ts

@@ -4,6 +4,7 @@ import {
   type ToolExecution,
 } from '@botonic/core'
 import type { ModelSettings } from '@openai/agents'
+import { LLM_PROVIDER } from './constants'
 import type { AgenticInputMessage, MemoryOptions, RunResult } from './types'
 
 const PREFIX = '[BotonicPluginAiAgents]'
@@ -43,6 +44,7 @@ export interface DebugLogger {
 class EnabledDebugLogger implements DebugLogger {
   logInitialConfig(config: DebugLoggerConfig): void {
     console.log(`${PREFIX} === Plugin Initialization ===`)
+    console.log(`${PREFIX} Provider: ${LLM_PROVIDER}`)
     console.log(
       `${PREFIX} Message History API Version: ${config.messageHistoryApiVersion}`
     )
@@ -155,21 +157,13 @@ class EnabledDebugLogger implements DebugLogger {
 }
 
 class DisabledDebugLogger implements DebugLogger {
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logInitialConfig(): void {}
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logAgentDebugInfo(): void {}
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logModelSettings(): void {}
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logRunnerStart(_model: string, _modelSettings: ModelSettings): void {}
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logRunResult(): void {}
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logGuardrailTriggered(): void {}
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logRunnerError(): void {}
-  // biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op implementation
   logToolExecution(): void {}
 }
 

package/src/guardrails/input.ts

@@ -123,7 +123,6 @@ async function sendGuardrailLlmRunTracking(
   const durationPerCall = Math.round(totalDuration / rawResponses.length)
   const temperature =
     (llmConfig.modelSettings.temperature as number | undefined) ?? 0
-
   const llmRuns = rawResponses.map(response => ({
     inference_id: trackingContext.inferenceId,
     is_test: trackingContext.isTest,

package/src/index.ts

@@ -132,13 +132,13 @@ export default class BotonicPluginAiAgents<
     authToken: string,
     inferenceId: string
   ) {
-    const llmConfig = new LLMConfig(
-      this.maxRetries,
-      this.timeout,
-      aiAgentArgs.model,
-      aiAgentArgs.verbosity,
-      botContext
-    )
+    const llmConfig = new LLMConfig({
+      maxRetries: this.maxRetries,
+      timeout: this.timeout,
+      modelName: aiAgentArgs.model,
+      verbosity: aiAgentArgs.verbosity,
+      botContext,
+    })
 
     // Get LLM config, tools and agent
     const { tools, agent } = await this.getSpecialistAgentAndTools(
@@ -194,13 +194,13 @@ export default class BotonicPluginAiAgents<
   ) {
     const { specialists, name, instructions } = aiAgentArgs
 
-    const llmConfig = new LLMConfig(
-      this.maxRetries,
-      this.timeout,
-      aiAgentArgs.model,
-      aiAgentArgs.verbosity,
-      botContext
-    )
+    const llmConfig = new LLMConfig({
+      maxRetries: this.maxRetries,
+      timeout: this.timeout,
+      modelName: aiAgentArgs.model,
+      verbosity: aiAgentArgs.verbosity,
+      botContext,
+    })
 
     const specialistsAgents = await Promise.all(
       specialists.map(async specialistData => {

package/src/llm-config.ts

@@ -7,15 +7,22 @@ import {
 } from '@openai/agents'
 import OpenAI, { AzureOpenAI } from 'openai'
 import {
-  AZURE_OPENAI_API_BASE,
-  AZURE_OPENAI_API_KEY,
-  AZURE_OPENAI_API_VERSION,
   isProd,
-  LITELLM_TAG_KEYS,
+  LLM_API_KEY,
+  LLM_API_URL,
+  LLM_AZURE_API_VERSION,
+  LLM_OPENAI_MODEL,
+  LLM_PROVIDER,
   LLM_PROVIDERS,
 } from './constants'
 
-export type LLMProvider = (typeof LLM_PROVIDERS)[keyof typeof LLM_PROVIDERS]
+export interface LLMConfigParams {
+  maxRetries: number
+  timeout: number
+  modelName: string
+  verbosity: VerbosityLevel
+  botContext: BotContext
+}
 
 export class LLMConfig {
   private readonly maxRetries: number
@@ -25,17 +32,18 @@ export class LLMConfig {
   public readonly modelSettings: ModelSettings
   public readonly modelProvider: ModelProvider
 
-  constructor(
-    maxRetries: number,
-    timeout: number,
-    modelName: string,
-    verbosity: VerbosityLevel,
-    botContext: BotContext
-  ) {
+  constructor({
+    maxRetries,
+    timeout,
+    modelName,
+    verbosity,
+    botContext,
+  }: LLMConfigParams) {
     this.maxRetries = maxRetries
     this.timeout = timeout
     this.botContext = botContext
-    this.modelName = modelName
+    this.modelName =
+      LLM_PROVIDER === LLM_PROVIDERS.OPENAI ? LLM_OPENAI_MODEL : modelName
     this.modelProvider = this.getModelProvider()
     this.modelSettings = this.getModelSettings(modelName, verbosity)
   }
@@ -44,19 +52,6 @@ export class LLMConfig {
     return await this.modelProvider.getModel(this.modelName)
   }
 
-  getProviderName(): LLMProvider {
-    return this.botContext.settings.LITELLM_API_URL
-      ? LLM_PROVIDERS.LITELLM
-      : LLM_PROVIDERS.AZURE
-  }
-
-  getApiVersion(): string | undefined {
-    return this.getProviderName() === LLM_PROVIDERS.AZURE
-      ? this.botContext.settings.AZURE_OPENAI_API_VERSION ||
-          AZURE_OPENAI_API_VERSION
-      : undefined
-  }
-
   private getModelProvider(): ModelProvider {
     const client = this.getClient()
     return new OpenAIProvider({
@@ -66,49 +61,32 @@ export class LLMConfig {
   }
 
   private getClient(): OpenAI | AzureOpenAI {
-    if (this.botContext.settings.LITELLM_API_URL) {
-      return this.getLiteLLMClient()
+    if (LLM_PROVIDER === LLM_PROVIDERS.OPENAI) {
+      return this.getOpenAIClient()
     }
 
-    return this.getAzureClient()
-  }
-
-  private buildLiteLLMTags(): { 'x-litellm-tags': string } | undefined {
-    const botId = this.botContext.session.bot.id
-    const orgId = this.botContext.session.organization_id
-    const parts: string[] = []
-    if (botId) {
-      parts.push(`${LITELLM_TAG_KEYS.BOT_ID}:${botId}`)
-    }
-    if (orgId) {
-      parts.push(`${LITELLM_TAG_KEYS.ORG_ID}:${orgId}`)
-    }
-    return parts.length > 0
-      ? { 'x-litellm-tags': parts.join(LITELLM_TAG_KEYS.SEPARATOR) }
-      : undefined
+    return this.getAzureOpenAiClient()
   }
 
-  private getLiteLLMClient(): OpenAI {
+  private getOpenAIClient(): OpenAI {
     return new OpenAI({
-      apiKey: this.botContext.secrets.LITELLM_API_KEY,
-      baseURL: this.botContext.settings.LITELLM_API_URL,
+      apiKey: this.botContext.secrets.AZURE_OPENAI_API_KEY || LLM_API_KEY,
       timeout: this.timeout,
       maxRetries: this.maxRetries,
       dangerouslyAllowBrowser: !isProd,
-      defaultHeaders: this.buildLiteLLMTags(),
     })
   }
 
-  private getAzureClient(): AzureOpenAI {
+  private getAzureOpenAiClient(): AzureOpenAI {
+    const baseURL = `${this.botContext.settings.AZURE_OPENAI_API_BASE || LLM_API_URL}openai/`
+
     return new AzureOpenAI({
-      apiKey:
-        this.botContext.secrets.AZURE_OPENAI_API_KEY || AZURE_OPENAI_API_KEY,
+      apiKey: this.botContext.secrets.AZURE_OPENAI_API_KEY || LLM_API_KEY,
       apiVersion:
         this.botContext.settings.AZURE_OPENAI_API_VERSION ||
-        AZURE_OPENAI_API_VERSION,
+        LLM_AZURE_API_VERSION,
       deployment: this.modelName,
-      baseURL:
-        this.botContext.settings.AZURE_OPENAI_API_BASE || AZURE_OPENAI_API_BASE,
+      baseURL,
       timeout: this.timeout,
       maxRetries: this.maxRetries,
       dangerouslyAllowBrowser: !isProd,
@@ -119,6 +97,14 @@ export class LLMConfig {
     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,
@@ -126,10 +112,15 @@ export class LLMConfig {
       }
     }
 
-    return {
-      reasoning: { effort: 'none' },
-      temperature: 1,
-      text: { verbosity },
+    throw new Error(`Unsupported model: ${model}`)
+  }
+
+  getApiVersion(): string {
+    if (LLM_PROVIDER !== LLM_PROVIDERS.AZURE) {
+      return 'NOT_API_VERSION_FOR_OPENAI_PROVIDER'
     }
+    return (
+      this.botContext.settings.AZURE_OPENAI_API_VERSION || LLM_AZURE_API_VERSION
+    )
   }
 }

package/src/runners/base-runner.ts

@@ -86,24 +86,11 @@ export abstract class BaseRunner<
 
       return runResult
     } catch (error) {
-      if (error instanceof InputGuardrailTripwireTriggered) {
-        const runResult: RunResult = {
-          startingAgentName: '',
-          lastAgentName: '',
-          availableSpecialists: [],
-          isTransferredToSpecialist: false,
-          messages: [],
-          memoryLength: 0,
-          toolsExecuted: [],
-          exit: true,
-          error: false,
-          inputGuardrailsTriggered: error.result.output.outputInfo,
-          outputGuardrailsTriggered: [],
-        }
-
-        this.logger.logGuardrailTriggered()
-        this.logger.logRunResult(runResult, startTime)
-
+      const runResult = this.handleInputGuardrailTripwireTriggered(
+        error,
+        startTime
+      )
+      if (runResult) {
         return runResult
       }
 
@@ -263,7 +250,6 @@ export abstract class BaseRunner<
     const durationPerCall = Math.round(totalDuration / rawResponses.length)
     const temperature =
       (this.llmConfig.modelSettings.temperature as number | undefined) ?? 0
-
     const llmRuns = rawResponses.map(response => ({
       inference_id: this.inferenceId,
       is_test: isTest,
@@ -286,4 +272,30 @@ export abstract class BaseRunner<
       llm_runs: llmRuns,
     })
   }
+
+  protected handleInputGuardrailTripwireTriggered(
+    error: unknown,
+    startTime: number
+  ): RunResult | undefined {
+    if (error instanceof InputGuardrailTripwireTriggered) {
+      const runResult: RunResult = {
+        startingAgentName: '',
+        lastAgentName: '',
+        availableSpecialists: [],
+        isTransferredToSpecialist: false,
+        messages: [],
+        memoryLength: 0,
+        toolsExecuted: [],
+        exit: true,
+        error: false,
+        inputGuardrailsTriggered: error.result.output.outputInfo,
+        outputGuardrailsTriggered: [],
+      }
+
+      this.logger.logGuardrailTriggered()
+      this.logger.logRunResult(runResult, startTime)
+
+      return runResult
+    }
+  }
 }

package/src/runners/router-runner.ts

@@ -1,4 +1,4 @@
-import type { ResolvedPlugins } from '@botonic/core'
+import type { AvailableSpecialist, ResolvedPlugins } from '@botonic/core'
 import { Handoff } from '@openai/agents'
 import type { Agent } from '@openai/agents-core'
 
@@ -16,17 +16,7 @@ export class RouterRunner<
   ): RunResult {
     const base = super.buildRunResult(result, context, memoryLength)
 
-    const availableSpecialists = (this.agent.handoffs ?? []).map(
-      (entry: Agent<any, any> | Handoff<any, any>) => {
-        const isHandoff = entry instanceof Handoff
-        const agent = isHandoff ? entry.agent : (entry as Agent<any, any>)
-        const description = isHandoff
-          ? entry.toolDescription
-          : agent.handoffDescription
-        return { name: agent.name, description }
-      }
-    )
-
+    const availableSpecialists = this.getAvailableSpecialists()
     const startingAgentName = this.agent.name ?? ''
     const lastAgentName = result.lastAgent?.name ?? ''
 
@@ -38,4 +28,37 @@ export class RouterRunner<
       isTransferredToSpecialist: startingAgentName !== lastAgentName,
     }
   }
+
+  protected override handleInputGuardrailTripwireTriggered(
+    error: unknown,
+    startTime: number
+  ): RunResult | undefined {
+    const runResult = super.handleInputGuardrailTripwireTriggered(
+      error,
+      startTime
+    )
+    if (runResult) {
+      // Override attributes to match router agent
+      runResult.startingAgentName = this.agent.name
+      runResult.lastAgentName = this.agent.name
+      runResult.availableSpecialists = this.getAvailableSpecialists()
+      runResult.isTransferredToSpecialist = false
+
+      return runResult
+    }
+    return undefined
+  }
+
+  private getAvailableSpecialists(): AvailableSpecialist[] {
+    return (this.agent.handoffs ?? []).map(
+      (entry: Agent<any, any> | Handoff<any, any>) => {
+        const isHandoff = entry instanceof Handoff
+        const agent = isHandoff ? entry.agent : (entry as Agent<any, any>)
+        const description = isHandoff
+          ? entry.toolDescription
+          : agent.handoffDescription
+        return { name: agent.name, description }
+      }
+    )
+  }
 }

package/src/services/types.ts

@@ -17,7 +17,7 @@ export interface LlmRunData {
   deployment_name: string
   model_name: string
   feature: string
-  api_version?: string
+  api_version: string
   num_prompt_tokens: number
   num_completion_tokens: number
   duration_in_milliseconds: number