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

package/src/llm-config.ts

@@ -1,4 +1,4 @@
-import type { VerbosityLevel } from '@botonic/core'
+import type { BotContext, VerbosityLevel } from '@botonic/core'
 import {
   type Model,
   type ModelProvider,
@@ -11,14 +11,16 @@ import {
   AZURE_OPENAI_API_KEY,
   AZURE_OPENAI_API_VERSION,
   isProd,
-  OPENAI_API_KEY,
-  OPENAI_MODEL,
-  OPENAI_PROVIDER,
+  LITELLM_TAG_KEYS,
+  LLM_PROVIDERS,
 } from './constants'
 
+export type LLMProvider = (typeof LLM_PROVIDERS)[keyof typeof LLM_PROVIDERS]
+
 export class LLMConfig {
   private readonly maxRetries: number
   private readonly timeout: number
+  private readonly botContext: BotContext
   public readonly modelName: string
   public readonly modelSettings: ModelSettings
   public readonly modelProvider: ModelProvider
@@ -27,11 +29,13 @@ export class LLMConfig {
     maxRetries: number,
     timeout: number,
     modelName: string,
-    verbosity: VerbosityLevel
+    verbosity: VerbosityLevel,
+    botContext: BotContext
   ) {
     this.maxRetries = maxRetries
     this.timeout = timeout
-    this.modelName = OPENAI_PROVIDER === 'openai' ? OPENAI_MODEL : modelName
+    this.botContext = botContext
+    this.modelName = modelName
     this.modelProvider = this.getModelProvider()
     this.modelSettings = this.getModelSettings(modelName, verbosity)
   }
@@ -40,6 +44,19 @@ 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({
@@ -49,28 +66,49 @@ export class LLMConfig {
   }
 
   private getClient(): OpenAI | AzureOpenAI {
-    if (OPENAI_PROVIDER === 'openai') {
-      return this.getOpenAIClient()
+    if (this.botContext.settings.LITELLM_API_URL) {
+      return this.getLiteLLMClient()
     }
 
     return this.getAzureClient()
   }
 
-  private getOpenAIClient(): OpenAI {
+  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
+  }
+
+  private getLiteLLMClient(): OpenAI {
     return new OpenAI({
-      apiKey: OPENAI_API_KEY,
+      apiKey: this.botContext.secrets.LITELLM_API_KEY,
+      baseURL: this.botContext.settings.LITELLM_API_URL,
       timeout: this.timeout,
       maxRetries: this.maxRetries,
       dangerouslyAllowBrowser: !isProd,
+      defaultHeaders: this.buildLiteLLMTags(),
     })
   }
 
   private getAzureClient(): AzureOpenAI {
     return new AzureOpenAI({
-      apiKey: AZURE_OPENAI_API_KEY,
-      apiVersion: AZURE_OPENAI_API_VERSION,
+      apiKey:
+        this.botContext.secrets.AZURE_OPENAI_API_KEY || AZURE_OPENAI_API_KEY,
+      apiVersion:
+        this.botContext.settings.AZURE_OPENAI_API_VERSION ||
+        AZURE_OPENAI_API_VERSION,
       deployment: this.modelName,
-      baseURL: AZURE_OPENAI_API_BASE,
+      baseURL:
+        this.botContext.settings.AZURE_OPENAI_API_BASE || AZURE_OPENAI_API_BASE,
       timeout: this.timeout,
       maxRetries: this.maxRetries,
       dangerouslyAllowBrowser: !isProd,
@@ -81,14 +119,6 @@ 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,
@@ -96,14 +126,10 @@ export class LLMConfig {
       }
     }
 
-    throw new Error(`Unsupported model: ${model}`)
+    return {
+      reasoning: { effort: 'none' },
+      temperature: 1,
+      text: { verbosity },
+    }
   }
 }
-
-export function getApiVersion(): string {
-  // Return NOT_API_VERSION_FOR_OPENAI_PROVIDER if OPENAI_PROVIDER
-  // is not azure to avoid error when tracking in llm_runs endpoint
-  return OPENAI_PROVIDER === 'azure'
-    ? AZURE_OPENAI_API_VERSION
-    : 'NOT_API_VERSION_FOR_OPENAI_PROVIDER'
-}

package/src/runners/base-runner.ts

@@ -3,13 +3,18 @@ import type {
   ResolvedPlugins,
   ToolExecution,
 } from '@botonic/core'
-import { InputGuardrailTripwireTriggered, Runner } from '@openai/agents'
-
+import {
+  InputGuardrailTripwireTriggered,
+  Runner,
+  RunToolCallItem,
+  RunToolCallOutputItem,
+} from '@openai/agents'
 import { isProd } from '../constants'
 import type { DebugLogger } from '../debug-logger'
-import { getApiVersion, type LLMConfig } from '../llm-config'
+import type { LLMConfig } from '../llm-config'
 import { HubtypeApiClient } from '../services/hubtype-api-client'
 import { TrackFeature, TrackProductName } from '../services/types'
+import { RETRIEVE_KNOWLEDGE_TOOL_NAME } from '../tools'
 import type {
   AgenticInputMessage,
   AgenticOutputMessage,
@@ -109,10 +114,105 @@ export abstract class BaseRunner<
   }
 
   protected getToolsExecuted(
-    _result: RunnerResult,
-    _context: Context<TPlugins, TExtraData>
+    result: RunnerResult,
+    context: Context<TPlugins, TExtraData>
   ): ToolExecution[] {
-    return []
+    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 === RETRIEVE_KNOWLEDGE_TOOL_NAME) {
+      return {
+        ...toolExecution,
+        knowledgebaseSourcesIds: context.knowledgeUsed.sourceIds,
+        knowledgebaseChunksIds: context.knowledgeUsed.chunksIds,
+      }
+    }
+
+    return toolExecution
+  }
+
+  private getSafeToolArguments(
+    rawToolArguments: string
+  ): Record<string, unknown> {
+    try {
+      return JSON.parse(rawToolArguments)
+    } catch (_error) {
+      return {}
+    }
   }
 
   protected buildRunResult(
@@ -163,7 +263,6 @@ export abstract class BaseRunner<
     const durationPerCall = Math.round(totalDuration / rawResponses.length)
     const temperature =
       (this.llmConfig.modelSettings.temperature as number | undefined) ?? 0
-    const apiVersion = getApiVersion()
 
     const llmRuns = rawResponses.map(response => ({
       inference_id: this.inferenceId,
@@ -174,7 +273,7 @@ export abstract class BaseRunner<
         (response.providerData?.model as string | undefined) ??
         this.llmConfig.modelName,
       feature: TrackFeature.AI_AGENT_RUN,
-      api_version: apiVersion,
+      api_version: this.llmConfig.getApiVersion(),
       num_prompt_tokens: response.usage.inputTokens,
       num_completion_tokens: response.usage.outputTokens,
       duration_in_milliseconds: durationPerCall,

package/src/runners/index.ts

@@ -1,2 +1,2 @@
 export { RouterRunner } from './router-runner'
-export { SpecialistRunner as WorkerRunner } from './specialist-runner'
+export { SpecialistRunner } from './specialist-runner'

package/src/runners/specialist-runner.ts

@@ -1,112 +1,7 @@
-import type { ResolvedPlugins, ToolExecution } from '@botonic/core'
-import { RunToolCallItem, RunToolCallOutputItem } from '@openai/agents'
-import { RETRIEVE_KNOWLEDGE_TOOL_NAME } from '../tools'
-import type { Context } from '../types'
-import { BaseRunner, type RunnerResult } from './base-runner'
+import type { ResolvedPlugins } from '@botonic/core'
+import { BaseRunner } from './base-runner'
 
 export class SpecialistRunner<
   TPlugins extends ResolvedPlugins = ResolvedPlugins,
   TExtraData = unknown,
-> extends BaseRunner<TPlugins, TExtraData> {
-  protected getToolsExecuted(
-    result: RunnerResult,
-    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 === RETRIEVE_KNOWLEDGE_TOOL_NAME) {
-      return {
-        ...toolExecution,
-        knowledgebaseSourcesIds: context.knowledgeUsed.sourceIds,
-        knowledgebaseChunksIds: context.knowledgeUsed.chunksIds,
-      }
-    }
-
-    return toolExecution
-  }
-
-  private getSafeToolArguments(
-    rawToolArguments: string
-  ): Record<string, unknown> {
-    try {
-      return JSON.parse(rawToolArguments)
-    } catch (_error) {
-      return {}
-    }
-  }
-}
+> extends BaseRunner<TPlugins, TExtraData> {}

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