Agent Platform

import { globalAgentRegistry, ReActAgent } from '@orka-js/agent';
import { OpenAIAdapter } from '@orka-js/openai';
 
// Create an agent
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY });
const agent = new ReActAgent({
  goal: 'Qualify leads and schedule follow-ups',
  tools: [emailTool, calendarTool, crmTool],
}, llm);
 
// Register with identity
await globalAgentRegistry.register(
  {
    id: 'sales-assistant-v1',
    name: 'Sales Assistant',
    role: 'CRM automation',
    description: 'Handles lead qualification and follow-ups',
    version: '1.0.0',
    metadata: {
      tags: ['sales', 'crm', 'automation'],
      capabilities: ['email', 'calendar', 'database'],
      author: 'YourCompany',
      license: 'MIT'
    }
  },
  agent.config,
  'react'
);
 
// Discover agents
const salesAgents = globalAgentRegistry.query({ tags: ['sales'] });
console.log(`Found ${salesAgents.length} sales agents`);

const metadata = {
  // Tags for categorization
  tags: ['sales', 'crm', 'automation', 'lead-qualification'],
 
  // Agent capabilities
  capabilities: ['email', 'calendar', 'database', 'reporting'],
 
  // Dependencies on other agents or services
  dependencies: ['email-service', 'crm-database'],
 
  // Author information
  author: 'YourCompany',
 
  // License
  license: 'MIT',
 
  // Custom fields
  custom: {
    department: 'Sales',
    costCenter: 'SALES-001',
    supportEmail: 'support@company.com'
  }
};

import { AgentRegistry } from '@orka-js/agent';
 
const registry = new AgentRegistry();
 
// Register an agent
const registered = await registry.register(
  {
    id: 'support-bot-v1',
    name: 'Support Bot',
    role: 'Customer support',
    description: 'Handles tier-1 support tickets and escalations',
    version: '1.0.0',
    metadata: {
      tags: ['support', 'customer-service', 'tickets'],
      capabilities: ['chat', 'ticketing', 'knowledge-base'],
      author: 'Support Team',
      license: 'proprietary'
    }
  },
  agentConfig,
  'react'
);
 
console.log(`Registered agent: ${registered.identity.name}`);

// Find all sales agents
const salesAgents = registry.query({ tags: ['sales'] });
 
// Find agents with email capability
const emailAgents = registry.query({ capabilities: ['email'] });
 
// Find agents by role
const supportAgents = registry.query({ role: 'support' });
 
// Search in name and description
const automationAgents = registry.query({ search: 'automation' });
 
// Combine multiple filters
const results = registry.query({
  tags: ['sales'],
  capabilities: ['email', 'calendar'],
  author: 'YourCompany',
  limit: 10
});
 
// Get specific agent
const agent = registry.get('sales-assistant-v1');
if (agent) {
  console.log(`Found: ${agent.identity.name} v${agent.identity.version}`);
}

// Update agent identity
await registry.update('sales-assistant-v1', {
  identity: {
    version: '1.1.0',
    description: 'Enhanced with AI-powered lead scoring'
  }
});
 
// Update agent configuration
await registry.update('sales-assistant-v1', {
  config: {
    maxSteps: 10,
    temperature: 0.7
  }
});

// Delete an agent
const deleted = registry.delete('old-agent-v1');
if (deleted) {
  console.log('Agent deleted successfully');
}
 
// Check if agent exists
if (registry.has('sales-assistant-v1')) {
  console.log('Agent exists');
}

const stats = registry.getStats();
 
console.log(`Total agents: ${stats.totalAgents}`);
console.log('Agents by type:', stats.agentsByType);
console.log('Popular tags:', stats.popularTags);
console.log('Popular capabilities:', stats.popularCapabilities);
 
// Example output:
// Total agents: 15
// Agents by type: { react: 8, 'plan-and-execute': 5, 'openai-functions': 2 }
// Popular tags: [
//   { tag: 'sales', count: 6 },
//   { tag: 'support', count: 4 },
//   { tag: 'automation', count: 8 }
// ]

// Export all agents as JSON
const json = registry.export();
await fs.writeFile('agents-backup.json', json);
 
// Import agents from JSON
const json = await fs.readFile('agents-backup.json', 'utf-8');
const imported = registry.import(json);
console.log(`Imported ${imported} agents`);
 
// Import with overwrite
const imported = registry.import(json, true); // Overwrites existing agents

import { globalAgentRegistry } from '@orka-js/agent';
 
// Register agents globally
await globalAgentRegistry.register(identity, config, type);
 
// Access from anywhere in your application
const agents = globalAgentRegistry.query({ tags: ['production'] });
 
// Clear all agents (useful for testing)
globalAgentRegistry.clear();

import { globalAgentRegistry, ReActAgent } from '@orka-js/agent';
import { OpenAIAdapter } from '@orka-js/openai';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY });
 
// 1. Lead Qualification Agent
const leadAgent = new ReActAgent({
  goal: 'Qualify incoming leads based on BANT criteria',
  tools: [crmTool, emailTool]
}, llm);
 
await globalAgentRegistry.register(
  {
    id: 'lead-qualifier-v1',
    name: 'Lead Qualifier',
    role: 'Lead qualification',
    description: 'Qualifies leads using BANT framework',
    version: '1.0.0',
    metadata: {
      tags: ['sales', 'lead-gen', 'qualification'],
      capabilities: ['crm', 'email', 'scoring'],
      author: 'Sales Team'
    }
  },
  leadAgent.config,
  'react'
);
 
// 2. Follow-up Agent
const followUpAgent = new ReActAgent({
  goal: 'Schedule and manage follow-up communications',
  tools: [calendarTool, emailTool]
}, llm);
 
await globalAgentRegistry.register(
  {
    id: 'follow-up-v1',
    name: 'Follow-up Manager',
    role: 'Follow-up automation',
    description: 'Manages follow-up schedule and communications',
    version: '1.0.0',
    metadata: {
      tags: ['sales', 'follow-up', 'scheduling'],
      capabilities: ['calendar', 'email', 'reminders'],
      dependencies: ['lead-qualifier-v1']
    }
  },
  followUpAgent.config,
  'react'
);
 
// 3. Proposal Generator
const proposalAgent = new ReActAgent({
  goal: 'Generate customized sales proposals',
  tools: [crmTool, documentTool]
}, llm);
 
await globalAgentRegistry.register(
  {
    id: 'proposal-gen-v1',
    name: 'Proposal Generator',
    role: 'Proposal creation',
    description: 'Creates customized proposals based on lead data',
    version: '1.0.0',
    metadata: {
      tags: ['sales', 'proposals', 'documents'],
      capabilities: ['document-generation', 'crm', 'templates'],
      dependencies: ['lead-qualifier-v1']
    }
  },
  proposalAgent.config,
  'react'
);
 
// Discover all sales agents
const salesTeam = globalAgentRegistry.query({ tags: ['sales'] });
console.log(`Sales team has ${salesTeam.length} agents`);
 
// Find agents that depend on lead qualifier
const dependentAgents = globalAgentRegistry.list().filter(agent =>
  agent.identity.metadata.dependencies?.includes('lead-qualifier-v1')
);
console.log(`${dependentAgents.length} agents depend on lead qualifier`);

// Agent Identity
interface AgentIdentity {
  id: string;
  name: string;
  role: string;
  description: string;
  version: string;
  createdAt: Date;
  updatedAt: Date;
  metadata: AgentMetadata;
}
 
// Agent Metadata
interface AgentMetadata {
  tags: string[];
  capabilities: string[];
  dependencies?: string[];
  author?: string;
  license?: string;
  custom?: Record<string, unknown>;
}
 
// Registered Agent
interface RegisteredAgent {
  identity: AgentIdentity;
  config: AgentConfig;
  type: 'react' | 'plan-and-execute' | 'openai-functions' | 'structured-chat' | 'custom';
  instance?: unknown;
}
 
// Query Options
interface AgentQueryOptions {
  tags?: string[];
  capabilities?: string[];
  role?: string;
  author?: string;
  search?: string;
  limit?: number;
}