@botonic/plugin-ai-agents 0.36.0-alpha.1 → 0.36.0-alpha.10

package/lib/esm/types.d.ts

@@ -1,29 +1,27 @@
+import { Agent, AgentInputItem, RunContext, Tool as OpenAITool } from '@openai/agents';
+import { ZodSchema } from 'zod';
+import { OutputMessage, OutputSchema } from './structured-output';
+export interface Context {
+    authToken: string;
+}
+export interface CustomTool {
+    name: string;
+    description: string;
+    schema: ZodSchema;
+    func: (input?: any, runContext?: RunContext<Context>) => Promise<any>;
+}
+export type Tool = OpenAITool<Context>;
+export type AIAgent = Agent<Context, typeof OutputSchema>;
 export interface PluginAiAgentOptions {
     authToken?: string;
+    customTools?: CustomTool[];
 }
 export interface AiAgentArgs {
     name: string;
     instructions: string;
+    activeTools?: {
+        name: string;
+    }[];
 }
-export interface AgenticBaseMessage {
-    role: 'assistant' | 'user' | 'tool' | 'exit';
-}
-export interface AssistantMessage extends AgenticBaseMessage {
-    role: 'assistant';
-    content: string;
-}
-export interface UserMessage extends AgenticBaseMessage {
-    role: 'user';
-    content: string;
-}
-export interface ToolMessage extends AgenticBaseMessage {
-    role: 'tool';
-    toolName: string;
-    toolOutput: string | null;
-}
-export interface ExitMessage extends AgenticBaseMessage {
-    role: 'exit';
-}
-export type AgenticInputMessage = AssistantMessage | UserMessage;
-export type AgenticOutputMessage = AssistantMessage | ToolMessage | ExitMessage;
-export type AgenticMessage = AssistantMessage | UserMessage | ToolMessage | ExitMessage;
+export type AgenticInputMessage = AgentInputItem;
+export type AgenticOutputMessage = OutputMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botonic/plugin-ai-agents",
-  "version": "0.36.0-alpha.1",
+  "version": "0.36.0-alpha.10",
   "main": "./lib/cjs/index.js",
   "module": "./lib/esm/index.js",
   "description": "Use AI Agents to generate your contents",
@@ -13,12 +13,12 @@
     "lint_core": "../../node_modules/.bin/eslint_d --cache --quiet 'src/**/*.ts*'"
   },
   "dependencies": {
-    "@botonic/core": "^0.36.0-alpha.0",
-    "@langchain/core": "^0.3.57",
-    "@langchain/langgraph": "^0.3.0",
-    "@langchain/openai": "^0.5.12",
-    "axios": "^1.9.0",
-    "uuid": "^10.0.0"
+    "@botonic/core": "^0.36.0",
+    "@openai/agents": "^0.0.10",
+    "axios": "^1.10.0",
+    "openai": "^5.8.3",
+    "uuid": "^10.0.0",
+    "zod": "^3.25.57"
   },
   "devDependencies": {
     "@types/uuid": "^10.0.0"

package/src/agent-builder.ts

@@ -0,0 +1,48 @@
+import { Agent } from '@openai/agents'
+
+import { OutputSchema } from './structured-output'
+import { mandatoryTools } from './tools'
+import { AIAgent, Tool } from './types'
+
+export class AIAgentBuilder {
+  private name: string
+  private instructions: string
+  private tools: Tool[]
+
+  constructor(name: string, instructions: string, tools: Tool[]) {
+    this.name = name
+    this.instructions = this.addExtraInstructions(instructions)
+    this.tools = this.addHubtypeTools(tools)
+  }
+
+  build(): AIAgent {
+    return new Agent({
+      name: this.name,
+      instructions: this.instructions,
+      tools: this.tools,
+      outputType: OutputSchema,
+    })
+  }
+
+  private addExtraInstructions(instructions: string): string {
+    const metadata = `Current Date: ${new Date().toISOString()}`
+    const example = {
+      messages: [
+        {
+          type: 'text',
+          content: {
+            text: 'Hello, how can I help you today?',
+          },
+        },
+      ],
+      numMessages: 1,
+    }
+    const output = `Return a JSON that follows the output schema provided. Never return multiple output schemas concatenated by a line break.\n<example>\n${JSON.stringify(example)}\n</example>`
+    return `<instructions>\n${instructions}\n</instructions>\n\n<metadata>\n${metadata}\n</metadata>\n\n<output>\n${output}\n</output>`
+  }
+
+  private addHubtypeTools(tools: Tool[]): Tool[] {
+    const hubtypeTools: Tool[] = [...mandatoryTools]
+    return [...hubtypeTools, ...tools]
+  }
+}

package/src/constants.ts

@@ -1,8 +1,11 @@
 export const HUBTYPE_API_URL =
   process.env.HUBTYPE_API_URL || 'https://api.hubtype.com'
 
-export const AZURE_OPENAI_API_KEY = process.env.AZURE_OPENAI_API_KEY
-export const AZURE_OPENAI_API_DEPLOYMENT_NAME =
-  process.env.AZURE_OPENAI_API_DEPLOYMENT_NAME
-export const AZURE_OPENAI_API_VERSION = process.env.AZURE_OPENAI_API_VERSION
+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_DEPLOYMENT_NAME =
+  process.env.AZURE_OPENAI_API_DEPLOYMENT_NAME || 'gpt-4o-mini_p1'
+export const AZURE_OPENAI_API_VERSION =
+  process.env.AZURE_OPENAI_API_VERSION || '2024-12-01-preview'
+
+export const isProd = process.env.NODE_ENV === 'production'

package/src/hubtype-api-client.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { BotContext } from '@botonic/core'
+import axios from 'axios'
+
+import { HUBTYPE_API_URL } from './constants'
+import { AgenticInputMessage } from './types'
+
+interface HubtypeAssistantMessage {
+  role: 'assistant'
+  content: string
+}
+
+interface HubtypeUserMessage {
+  role: 'user'
+  content: string
+}
+
+type HubtypeMessage = HubtypeAssistantMessage | HubtypeUserMessage
+
+export class HubtypeApiClient {
+  private readonly authToken: string
+
+  constructor(authToken: string) {
+    this.authToken = authToken
+  }
+
+  async getLocalMessages(memoryLength: number): Promise<AgenticInputMessage[]> {
+    const localBotonicState = localStorage.getItem('botonicState')
+    const botonicState = JSON.parse(localBotonicState || '{}')
+    const messages = botonicState.messages
+    const filteredMessages = messages
+      .filter(message => message.data.text)
+      .map(message => ({
+        role: message.sentBy === 'user' ? 'user' : 'assistant',
+        content: message.data.text,
+      }))
+      .map(message => this.formatMessage(message))
+    return filteredMessages.slice(-memoryLength)
+  }
+
+  async getMessages(
+    request: BotContext,
+    memoryLength: number
+  ): Promise<AgenticInputMessage[]> {
+    const url = `${HUBTYPE_API_URL}/external/v1/ai/agent/message_history/`
+    const headers = {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${this.authToken}`,
+    }
+    const params = {
+      last_message_id: request.input.message_id,
+      num_messages: memoryLength,
+    }
+
+    try {
+      const response = await axios.get<{ messages: HubtypeMessage[] }>(url, {
+        headers,
+        params,
+      })
+      const messages = response.data.messages
+      return messages.map(message => this.formatMessage(message))
+    } catch (error) {
+      console.error(error)
+      throw new Error('Failed to get messages from Hubtype')
+    }
+  }
+
+  private formatMessage(message: HubtypeMessage): AgenticInputMessage {
+    if (message.role === 'user') {
+      return {
+        content: message.content,
+        role: 'user',
+      }
+    } else if (message.role === 'assistant') {
+      return {
+        role: 'assistant',
+        content: [
+          {
+            type: 'output_text',
+            text: message.content,
+          },
+        ],
+        status: 'completed',
+      }
+    } else {
+      throw new Error('Invalid message role')
+    }
+  }
+}

package/src/index.ts

@@ -1,22 +1,29 @@
 import { BotContext, Plugin } from '@botonic/core'
+import { tool } from '@openai/agents'
 
-import { AiAgentClient } from './ai-agent-client'
-import { HubtypeClient } from './hubtype-client'
-import { MANDATORY_TOOLS } from './tools'
+import { AIAgentBuilder } from './agent-builder'
+import { isProd } from './constants'
+import { HubtypeApiClient } from './hubtype-api-client'
+import { setUpOpenAI } from './openai'
+import { AIAgentRunner } from './runner'
 import {
+  AgenticInputMessage,
   AgenticOutputMessage,
   AiAgentArgs,
+  Context,
+  CustomTool,
   PluginAiAgentOptions,
-  UserMessage,
+  Tool,
 } from './types'
-import { loadChatModel } from './utils'
-
-const isProd = process.env.NODE_ENV === 'production'
 
 export default class BotonicPluginAiAgents implements Plugin {
   private readonly authToken?: string
+  public toolDefinitions: CustomTool[] = []
+
   constructor(options?: PluginAiAgentOptions) {
+    setUpOpenAI()
     this.authToken = options?.authToken
+    this.toolDefinitions = options?.customTools || []
   }
 
   pre(): void {
@@ -26,31 +33,61 @@ export default class BotonicPluginAiAgents implements Plugin {
   async getInference(
     request: BotContext,
     aiAgentArgs: AiAgentArgs
-  ): Promise<AgenticOutputMessage | undefined> {
+  ): Promise<AgenticOutputMessage[] | undefined> {
     try {
       const authToken = isProd ? request.session._access_token : this.authToken
       if (!authToken) {
         throw new Error('Auth token is required')
       }
 
-      const hubtypeClient = new HubtypeClient(authToken)
-      const messages = isProd
-        ? await hubtypeClient.getMessages(request, 10)
-        : [{ role: 'user', content: request.input.data } as UserMessage]
+      const tools = this.buildTools(
+        aiAgentArgs.activeTools?.map(tool => tool.name) || []
+      )
+      const agent = new AIAgentBuilder(
+        aiAgentArgs.name,
+        aiAgentArgs.instructions,
+        tools
+      ).build()
 
-      const customTools = []
-      const chatModel = loadChatModel('azureOpenAI')
-      const aiAgentClient = new AiAgentClient(aiAgentArgs, chatModel, [
-        ...customTools,
-        ...MANDATORY_TOOLS,
-      ])
+      const messages = await this.getMessages(request, authToken, 25)
+      const context: Context = {
+        authToken,
+      }
 
-      return await aiAgentClient.runAgent(messages)
+      const runner = new AIAgentRunner(agent)
+      return await runner.run(messages, context)
     } catch (error) {
       console.error('error plugin returns undefined', error)
       return undefined
     }
   }
+
+  private async getMessages(
+    request: BotContext,
+    authToken: string,
+    memoryLength: number
+  ): Promise<AgenticInputMessage[]> {
+    if (isProd) {
+      const hubtypeClient = new HubtypeApiClient(authToken)
+      return await hubtypeClient.getMessages(request, memoryLength)
+    }
+    const hubtypeClient = new HubtypeApiClient(authToken)
+    return await hubtypeClient.getLocalMessages(memoryLength)
+  }
+
+  private buildTools(activeToolNames: string[]): Tool[] {
+    const availableTools = this.toolDefinitions.filter(tool =>
+      activeToolNames.includes(tool.name)
+    )
+    return availableTools.map(toolDefinition => {
+      return tool<any, Context, any>({
+        name: toolDefinition.name,
+        description: toolDefinition.description,
+        parameters: toolDefinition.schema,
+        execute: toolDefinition.func,
+      })
+    })
+  }
 }
 
 export * from './types'

package/src/openai.ts

@@ -0,0 +1,30 @@
+import {
+  setDefaultOpenAIClient,
+  setOpenAIAPI,
+  setTracingDisabled,
+} from '@openai/agents'
+import { AzureOpenAI } from 'openai'
+import {
+  AZURE_OPENAI_API_BASE,
+  AZURE_OPENAI_API_DEPLOYMENT_NAME,
+  AZURE_OPENAI_API_KEY,
+  AZURE_OPENAI_API_VERSION,
+  isProd,
+} from './constants'
+
+export function setUpOpenAI() {
+  setAzureOpenAIClient()
+  setOpenAIAPI('chat_completions')
+  setTracingDisabled(true)
+}
+
+function setAzureOpenAIClient() {
+  const client = new AzureOpenAI({
+    apiKey: AZURE_OPENAI_API_KEY,
+    apiVersion: AZURE_OPENAI_API_VERSION,
+    deployment: AZURE_OPENAI_API_DEPLOYMENT_NAME,
+    baseURL: AZURE_OPENAI_API_BASE,
+    dangerouslyAllowBrowser: !isProd,
+  })
+  setDefaultOpenAIClient(client)
+}

package/src/runner.ts

@@ -0,0 +1,43 @@
+import { Runner } from '@openai/agents'
+import {
+  AIAgent,
+  AgenticInputMessage,
+  AgenticOutputMessage,
+  Context,
+} from './types'
+
+export class AIAgentRunner {
+  private agent: AIAgent
+
+  constructor(agent: AIAgent) {
+    this.agent = agent
+  }
+
+  async run(
+    messages: AgenticInputMessage[],
+    context: Context,
+    maxRetries: number = 1
+  ): Promise<AgenticOutputMessage[]> {
+    return this.runWithRetry(messages, context, maxRetries, 1)
+  }
+
+  private async runWithRetry(
+    messages: AgenticInputMessage[],
+    context: Context,
+    maxRetries: number,
+    attempt: number
+  ): Promise<AgenticOutputMessage[]> {
+    try {
+      const runner = new Runner({
+        modelSettings: { temperature: 0 },
+      })
+      const result = await runner.run(this.agent, messages, { context })
+      return result.finalOutput?.messages || []
+    } catch (error) {
+      if (attempt > maxRetries) {
+        throw error
+      }
+      return this.runWithRetry(messages, context, maxRetries, attempt + 1)
+    }
+  }
+}

package/src/structured-output/carousel.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod'
+
+import { BaseMessage } from './shared'
+
+interface CarouselElement {
+  title: string
+  subtitle: string
+  image: string
+  button: { text: string; url: string }
+}
+
+export interface CarouselMessage extends BaseMessage {
+  type: 'carousel'
+  content: {
+    elements: CarouselElement[]
+  }
+}
+
+export const CarouselSchema = z
+  .object({
+    type: z.enum(['carousel']),
+    content: z.object({
+      elements: z.array(
+        z.object({
+          title: z.string(),
+          subtitle: z.string(),
+          image: z.string(),
+          button: z.object({
+            text: z.string(),
+            url: z.string(),
+          }),
+        })
+      ),
+    }),
+  })
+  .describe('A carousel message containing a list of elements')

package/src/structured-output/exit.ts

@@ -0,0 +1,15 @@
+import z from 'zod'
+
+import { BaseMessage } from './shared'
+
+export interface ExitMessage extends BaseMessage {
+  type: 'exit'
+}
+
+export const ExitSchema = z
+  .object({
+    type: z.enum(['exit']),
+  })
+  .describe(
+    'An exit message. This message should only be used to exit the agent due to out of context or the user asking to exit the conversation'
+  )

package/src/structured-output/index.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod'
+
+import { CarouselMessage, CarouselSchema } from './carousel'
+import { ExitMessage, ExitSchema } from './exit'
+import { TextMessage, TextSchema } from './text'
+import {
+  TextWithButtonsMessage,
+  TextWithButtonsSchema,
+} from './text-with-buttons'
+
+export type OutputMessage =
+  | TextMessage
+  | TextWithButtonsMessage
+  | CarouselMessage
+  | ExitMessage
+
+export interface Output {
+  messages: OutputMessage[]
+}
+
+export const OutputSchema = z
+  .object({
+    messages: z.array(
+      z.union([TextSchema, TextWithButtonsSchema, CarouselSchema, ExitSchema])
+    ),
+  })
+  .describe('The messages to be sent to the user')

package/src/structured-output/shared.ts

@@ -0,0 +1,3 @@
+export interface BaseMessage {
+  type: 'text' | 'textWithButtons' | 'carousel' | 'exit'
+}

package/src/structured-output/text-with-buttons.ts

@@ -0,0 +1,23 @@
+import z from 'zod'
+
+import { BaseMessage } from './shared'
+
+export interface TextWithButtonsMessage extends BaseMessage {
+  type: 'textWithButtons'
+  content: {
+    text: string
+    buttons: string[]
+  }
+}
+
+export const TextWithButtonsSchema = z
+  .object({
+    type: z.enum(['textWithButtons']),
+    content: z.object({
+      text: z.string(),
+      buttons: z.array(z.string()),
+    }),
+  })
+  .describe(
+    'A text message with buttons to allow the user to use quick replies'
+  )

package/src/structured-output/text.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod'
+
+import { BaseMessage } from './shared'
+
+export interface TextMessage extends BaseMessage {
+  type: 'text'
+  content: {
+    text: string
+  }
+}
+
+export const TextSchema = z
+  .object({
+    type: z.enum(['text']),
+    content: z.object({
+      text: z.string(),
+    }),
+  })
+  .describe('A text message')

package/src/tools/index.ts

@@ -0,0 +1,3 @@
+import { Tool } from '../types'
+
+export const mandatoryTools: Tool[] = []

package/src/types.ts

@@ -1,39 +1,37 @@
-export interface PluginAiAgentOptions {
-  authToken?: string
-}
-export interface AiAgentArgs {
-  name: string
-  instructions: string
-}
+import {
+  Agent,
+  AgentInputItem,
+  RunContext,
+  Tool as OpenAITool,
+} from '@openai/agents'
+import { ZodSchema } from 'zod'
 
-export interface AgenticBaseMessage {
-  role: 'assistant' | 'user' | 'tool' | 'exit'
-}
+import { OutputMessage, OutputSchema } from './structured-output'
 
-export interface AssistantMessage extends AgenticBaseMessage {
-  role: 'assistant'
-  content: string
+export interface Context {
+  authToken: string
 }
 
-export interface UserMessage extends AgenticBaseMessage {
-  role: 'user'
-  content: string
+export interface CustomTool {
+  name: string
+  description: string
+  schema: ZodSchema
+  func: (input?: any, runContext?: RunContext<Context>) => Promise<any>
 }
 
-export interface ToolMessage extends AgenticBaseMessage {
-  role: 'tool'
-  toolName: string
-  toolOutput: string | null
+export type Tool = OpenAITool<Context>
+export type AIAgent = Agent<Context, typeof OutputSchema>
+
+export interface PluginAiAgentOptions {
+  authToken?: string
+  customTools?: CustomTool[]
 }
 
-export interface ExitMessage extends AgenticBaseMessage {
-  role: 'exit'
+export interface AiAgentArgs {
+  name: string
+  instructions: string
+  activeTools?: { name: string }[]
 }
 
-export type AgenticInputMessage = AssistantMessage | UserMessage
-export type AgenticOutputMessage = AssistantMessage | ToolMessage | ExitMessage
-export type AgenticMessage =
-  | AssistantMessage
-  | UserMessage
-  | ToolMessage
-  | ExitMessage
+export type AgenticInputMessage = AgentInputItem
+export type AgenticOutputMessage = OutputMessage

package/lib/cjs/ai-agent-client.d.ts

@@ -1,11 +0,0 @@
-import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { StructuredTool } from '@langchain/core/tools';
-import { CompiledStateGraph } from '@langchain/langgraph';
-import { AgenticInputMessage, AgenticOutputMessage, AiAgentArgs } from './types';
-export declare class AiAgentClient {
-    name: string;
-    instructions: string;
-    agent: CompiledStateGraph<any, any>;
-    constructor(aiAgentArgs: AiAgentArgs, chatModel: BaseChatModel, tools?: StructuredTool[]);
-    runAgent(_messages: AgenticInputMessage[]): Promise<AgenticOutputMessage>;
-}