LangChain Tools

const defiAgent = agent.createAgent('defi');
const response = await defiAgent.chat("What's my current identity?");
// Returns: "Current identity: principal abc123..., account ID: def456..., type: secp256k1"

const response = await defiAgent.chat("Create a new anonymous identity called 'test-wallet'");
const response2 = await defiAgent.chat("Create an identity from seed phrase 'abandon abandon...' with key 'main-wallet'");

const response = await defiAgent.chat("What's my ICP balance?");
const response2 = await defiAgent.chat("Check balance for account abc123...");

const response = await defiAgent.chat("Transfer 2.5 ICP to account def456... with memo 'Payment for services'");

const response = await defiAgent.chat("Transfer 1000 tokens from canister xyz123... to principal abc456...");

const devAgent = agent.createAgent('developer');
const response = await devAgent.chat("Create a new canister with 10T cycles");

const response = await devAgent.chat("Deploy WASM from ./hello-world.wasm to canister abc123... in upgrade mode");

const response = await devAgent.chat("What's the status of canister xyz789...?");

const response = await devAgent.chat("Check cycles balance for canister abc123...");

const response = await devAgent.chat("Top up canister xyz789... with 5T cycles");

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

// Complete development workflow
await devAgent.chat("Create a new canister with 10T cycles");
await devAgent.chat("Deploy my hello-world.wasm to the canister");
await devAgent.chat("Check the canister status and cycles balance");
await devAgent.chat("If cycles are low, top up with 5T more");

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

// DeFi operations
await defiAgent.chat("What's my current ICP balance?");
await defiAgent.chat("Transfer 5 ICP to principal abc123... with memo 'Investment'");
await defiAgent.chat("Check my balance in token canister xyz789...");
await defiAgent.chat("Transfer 1000 tokens to def456...");

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

// Governance operations
await govAgent.chat("Show me current governance proposals");
await govAgent.chat("Vote YES on proposal 12345");
await govAgent.chat("Check my neuron status");
await govAgent.chat("Stake 10 ICP in governance");

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

// Complex multi-step workflow
await generalAgent.chat(`
  I want to deploy a new application:
  1. Create a canister with 20T cycles
  2. Deploy my app.wasm to it
  3. Check that it's running properly
  4. Transfer 1 ICP to the canister's account for operations
  5. Set up monitoring for cycles balance
`);

// Single operation
const result = await agent.processNaturalLanguage("Check my ICP balance");

// Complex operation
const result = await agent.processNaturalLanguage(
  "Create a new canister, deploy my hello-world.wasm, and top it up with 5T cycles"
);

// Conditional operation
const result = await agent.processNaturalLanguage(
  "If my ICP balance is above 10 ICP, transfer 5 ICP to account abc123..."
);

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

const conversation = [
  "What's my current portfolio?",
  "Transfer 2 ICP to my trading account",
  "Check the balance after transfer",
  "If successful, also transfer 1000 tokens from my main token canister"
];

for (const message of conversation) {
  const response = await defiAgent.chat(message);
  console.log('Response:', response);
}

try {
  const response = await defiAgent.chat("Transfer 999999 ICP to invalid-account");
} catch (error) {
  // Handles validation errors, insufficient funds, invalid accounts, etc.
  console.log('Error:', error.message);
}

// Create a custom workflow combining multiple tools
const customWorkflow = async (agent: ICPSpecializedAgent) => {
  // Step 1: Check current state
  const balance = await agent.chat("What's my ICP balance?");
  
  // Step 2: Conditional logic
  if (parseFloat(balance) > 5) {
    await agent.chat("Create a new canister with 10T cycles");
    await agent.chat("Deploy my application WASM");
  }
  
  // Step 3: Monitoring setup
  await agent.chat("Check canister status and set up monitoring");
};

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

const operations = [
  "Check cycles balance for canister-1",
  "Check cycles balance for canister-2", 
  "Check cycles balance for canister-3",
  "Top up any canisters with less than 2T cycles"
];

const generalAgent = agent.createAgent('general');
for (const operation of operations) {
  const result = await generalAgent.chat(operation);
  console.log(`${operation}: ${result}`);
}

const agent = new ICPAgent({
  network: 'mainnet',
  openai: {
    apiKey: 'your-openai-key',
    model: 'gpt-4-turbo-preview', // or 'gpt-3.5-turbo'
    temperature: 0.1, // Lower for more deterministic responses
    maxTokens: 1000
  }
});

// Create agent with only specific tools
const limitedAgent = agent.createAgent('defi', {
  enabledTools: ['get-balance', 'transfer-icp', 'get-current-identity']
});

// Good: Specific and clear
await agent.chat("Transfer 2.5 ICP to account abc123 with memo 'payment'");

// Avoid: Ambiguous or unclear
await agent.chat("send some tokens somewhere");

const safeTransfer = async (agent, to, amount) => {
  try {
    // First check balance
    const balance = await agent.chat("What's my ICP balance?");
    
    // Then attempt transfer
    const result = await agent.chat(`Transfer ${amount} ICP to ${to}`);
    return result;
  } catch (error) {
    console.log('Transfer failed, checking balance...');
    await agent.chat("What's my current balance?");
    throw error;
  }
};

// Validate operations completed successfully
const deployWorkflow = async (agent) => {
  const createResult = await agent.chat("Create canister with 10T cycles");
  
  // Verify creation
  const status = await agent.chat("Get status of the new canister");
  
  if (status.includes('running')) {
    await agent.chat("Deploy my app.wasm to the canister");
  } else {
    throw new Error('Canister creation failed');
  }
};