Overview

import { ExuluAgent } from "@exulu/backend";
import { createOpenAI } from "@ai-sdk/openai";

// Create an agent
const assistantAgent = new ExuluAgent({
  id: "assistant",
  name: "Assistant",
  type: "agent",
  description: "A helpful AI assistant",
  provider: "openai",
  config: {
    name: "gpt-4o",
    model: {
      create: ({ apiKey }) => createOpenAI({ apiKey })("gpt-4o")
    },
    instructions: "You are a helpful assistant. Answer questions clearly and concisely."
  },
  capabilities: {
    text: true,
    images: [".png", ".jpg", ".jpeg"],
    files: [".pdf", ".docx", ".txt"],
    audio: [],
    video: []
  }
});

// Register with ExuluApp
const app = new ExuluApp();
await app.create({
  agents: {
    assistant: assistantAgent
  },
  config: { /* ... */ }
});

// Use the agent
const response = await assistantAgent.generateSync({
  prompt: "What is the capital of France?",
  agentInstance: await loadAgent("assistant"),
  currentTools: [],
  statistics: {
    label: "assistant",
    trigger: "api"
  }
});

console.log(response); // "The capital of France is Paris."

import { streamText, generateText, generateObject } from "ai";

// ExuluAgent uses these internally
const response = await generateText({
  model: agent.model.create({ apiKey }),
  prompt: "Hello!",
  tools: convertedTools
});

// Messages are stored in the database
const session = "session-123";
const previousMessages = await getAgentMessages({ session, user: userId });

// New messages are appended
const response = await agent.generateStream({
  message: newMessage,
  session: session,
  user: currentUser
});

const agent = new ExuluAgent({
  // ... agent config
});

// Tools are provided at runtime
const response = await agent.generateSync({
  prompt: "Search our docs for authentication",
  currentTools: [
    documentationSearchTool,
    databaseQueryTool,
    apiCallTool
  ]
});

config: {
  instructions: `You are a customer support agent for Acme Corp.

Guidelines:
- Be friendly and professional
- Answer questions about our products and services
- Escalate billing issues to human agents
- Provide accurate, helpful information

Company info:
- Founded in 2020
- Specializes in enterprise SaaS
- 24/7 support available`
}

capabilities: {
  text: true,                          // Text input
  images: [".png", ".jpg", ".jpeg"],   // Image files
  files: [".pdf", ".docx", ".txt"],    // Document files
  audio: [".mp3", ".wav"],             // Audio files
  video: [".mp4"]                      // Video files
}

const agent = new ExuluAgent({
  id: "assistant_with_memory",
  name: "Assistant with Memory",
  // ... other config
  config: {
    // ... model config
    memory: "user_interactions" // Context ID for memory
  }
});

workflows: {
  enabled: true,
  queue: await ExuluQueues.register("agent_workflows")
}

const chatAgent = new ExuluAgent({
  id: "chat_assistant",
  name: "Chat Assistant",
  type: "agent",
  description: "Conversational AI assistant",
  provider: "openai",
  config: {
    name: "gpt-4o",
    model: {
      create: ({ apiKey }) => createOpenAI({ apiKey })("gpt-4o")
    },
    instructions: "You are a friendly, helpful assistant."
  },
  capabilities: {
    text: true,
    images: [".png", ".jpg"],
    files: [".pdf", ".txt"],
    audio: [],
    video: []
  }
});

// Stream responses
const { stream } = await chatAgent.generateStream({
  message: newMessage,
  session: sessionId,
  user: currentUser,
  currentTools: [searchTool, calculatorTool]
});

const extractorAgent = new ExuluAgent({
  id: "data_extractor",
  name: "Data Extractor",
  type: "agent",
  description: "Extracts structured data from text",
  provider: "openai",
  config: {
    name: "gpt-4o-mini",
    model: {
      create: ({ apiKey }) => createOpenAI({ apiKey })("gpt-4o-mini")
    }
  },
  capabilities: {
    text: true,
    images: [],
    files: [".pdf", ".docx", ".txt"],
    audio: [],
    video: []
  }
});

// Generate structured output
const data = await extractorAgent.generateSync({
  prompt: "Extract contact information from this email",
  outputSchema: z.object({
    name: z.string(),
    email: z.string().email(),
    phone: z.string().optional()
  })
});

const specialistAgent = new ExuluAgent({
  id: "sql_specialist",
  name: "SQL Specialist",
  type: "agent",
  description: "Expert at writing SQL queries",
  provider: "openai",
  config: {
    name: "gpt-4o",
    model: { /* ... */ },
    instructions: "You are an expert SQL developer. Write optimized, secure queries."
  },
  capabilities: {
    text: true,
    images: [],
    files: [],
    audio: [],
    video: []
  }
});

// Export as tool
const sqlTool = await specialistAgent.tool(
  "sql_specialist",
  [specialistAgent],
  contexts,
  rerankers
);

// Main agent can use it
const mainAgent = new ExuluAgent({
  id: "main_assistant",
  name: "Main Assistant",
  type: "agent",
  description: "General assistant that can delegate to specialists",
  // ... config
});

const response = await mainAgent.generateSync({
  prompt: "Write a query to find top customers",
  currentTools: [sqlTool], // Main agent can call SQL specialist
  // ... other params
});