Specialized Agents

// Initialize the main agent first
const agent = new ICPAgent({
  network: 'mainnet',
  openai: { apiKey: process.env.OPENAI_API_KEY }
});
await agent.initialize();

// Create specialized agents
const generalAgent = agent.createAgent('general');
const developerAgent = agent.createAgent('developer');
const defiAgent = agent.createAgent('defi');
const governanceAgent = agent.createAgent('governance');

const generalAgent = agent.createAgent('general');

// Ask about capabilities
const capabilities = generalAgent.getCapabilities();
console.log(capabilities);

// Mixed operations
await generalAgent.chat("Check my balance and list my canisters");
await generalAgent.chat("Create an identity and deploy a canister");
await generalAgent.chat("Help me understand cycles management");

// Information gathering
User: "What can you help me with?"
Agent: "I can help with token operations, canister management, 
        cycles monitoring, and identity management..."

// Multi-domain task
User: "I need to set up a new project"
Agent: "I'll help you set up a new project. Let's start by:
        1. Creating a dedicated identity
        2. Setting up a canister with cycles
        3. Preparing for token operations..."

const devAgent = agent.createAgent('developer');

// Development queries
await devAgent.chat("What's the best practice for canister upgrades?");
await devAgent.chat("Help me deploy my WASM module");
await devAgent.chat("I'm getting an error during deployment");

// Get suggestions
const suggestions = devAgent.getSuggestions();
// Returns developer-focused suggestions

// Deployment workflow
User: "I need to deploy my dapp"
Agent: "I'll help you deploy your dapp. For development, I recommend:
        - Using 5T cycles for initial deployment
        - Setting up proper controller permissions
        - Testing with small cycles amounts first
        Let's start by creating a canister..."

// Debugging help
User: "My canister deployment failed"
Agent: "Let me help debug the deployment. Common issues include:
        - Insufficient cycles (need at least 1T)
        - WASM module size (max 2MB without chunking)
        - Controller permissions
        Let's check your canister status first..."

const defiAgent = agent.createAgent('defi');

// Token operations
await defiAgent.chat("I want to transfer tokens efficiently");
await defiAgent.chat("Help me manage my token portfolio");
await defiAgent.chat("What are the current transfer fees?");

// Get DeFi suggestions
const suggestions = defiAgent.getSuggestions();
// Returns finance-focused suggestions

// Transfer guidance
User: "I need to send ICP to multiple recipients"
Agent: "I'll help you with batch transfers. For multiple recipients:
        - Each transfer has a 0.0001 ICP fee
        - I'll validate all addresses first
        - You can include custom memos
        Who are the recipients and amounts?"

// Portfolio check
User: "Show me all my token balances"
Agent: "I'll check your complete token portfolio:
        - ICP balance: 25.5 ICP
        - ICRC-1 tokens: Checking registered tokens...
        - Total portfolio value: ..."

const govAgent = agent.createAgent('governance');

// AI-powered proposal analysis
const analysis = await govAgent.chat(
  "Analyze governance proposal PROP-2024-007 for community fund allocation"
);
// Returns: Detailed analysis with recommendation and confidence score

// Vote casting with AI reasoning
const vote = await govAgent.chat(
  "Cast YES vote on proposal PROP-2024-007 based on analysis"
);
// Returns: Vote confirmation with cryptographic proof

// Governance metrics
const metrics = await govAgent.chat(
  "Show current DAO voting statistics and participation rates"  
);
// Returns: Real-time governance analytics and insights

// DAO management operations
const management = await govAgent.chat(
  "Create new proposal for protocol upgrade with proper documentation"
);
// Returns: Structured proposal creation with validation

// Start with general exploration
const general = agent.createAgent('general');
await general.chat("What do I need to know about ICP?");

// Switch to development
const dev = agent.createAgent('developer');
await dev.chat("Now help me deploy a canister");

// Move to finance
const defi = agent.createAgent('defi');
await defi.chat("After deployment, help me manage tokens");

const devAgent = agent.createAgent('developer');

// First conversation
await devAgent.chat("I'm building a social dapp");
await devAgent.chat("What canister architecture do you recommend?");
// Agent remembers you're building a social dapp

// Clear context for new conversation
devAgent.clearContext();
await devAgent.chat("I need help with a DeFi project");
// Fresh context, no memory of social dapp

// Wrap agent with custom logic
class CustomDeFiAgent {
  constructor(private agent: ISpecializedAgent) {}
  
  async safeTransfer(amount: string, to: string) {
    // Add custom validation
    if (parseFloat(amount) > 100) {
      const confirm = await this.confirmLargeTransfer(amount);
      if (!confirm) return;
    }
    
    return this.agent.chat(`Transfer ${amount} ICP to ${to}`);
  }
}

const defi = new CustomDeFiAgent(agent.createAgent('defi'));

// Development → DeFi workflow
const dev = agent.createAgent('developer');
const defi = agent.createAgent('defi');

// Step 1: Deploy with developer agent
const deployment = await dev.chat("Deploy my token canister");

// Step 2: Manage tokens with DeFi agent  
const tokenMgmt = await defi.chat("Set up initial token distribution");