Overview

import { 
  LuaAgent, 
  LuaSkill, 
  LuaWebhook, 
  LuaJob,
  PreProcessor,
  PostProcessor 
} from 'lua-cli';

// Skills
import { customerServiceSkill } from './skills/customer-service';
import { productSkill } from './skills/products';

// Webhooks
const paymentWebhook = new LuaWebhook({
  name: 'stripe-payment',
  execute: async (event) => {
    if (event.type === 'payment.succeeded') {
      // Handle payment confirmation
      await notifyCustomer(event.data);
    }
  }
});

// Scheduled Jobs
const dailyReportJob = new LuaJob({
  name: 'daily-report',
  schedule: { type: 'cron', pattern: '0 9 * * *' },
  execute: async (job) => {
    const user = await job.user();
    await user.send([{ type: 'text', text: 'Daily report ready!' }]);
  }
});

// Message Processing
const profanityFilter = new PreProcessor({
  name: 'profanity-filter',
  execute: async (message, user) => {
    if (containsProfanity(message.content)) {
      return { block: true, response: "Please keep it respectful." };
    }
    return { block: false };
  }
});

const addDisclaimer = new PostProcessor({
  name: 'add-disclaimer',
  execute: async (user, message, response, channel) => {
    return {
      modifiedResponse: response + "\n\n_AI-generated content for informational purposes._"
    };
  }
});

// Complete Agent Configuration
export const agent = new LuaAgent({
  name: "enterprise-assistant",
  
  persona: `You are a professional enterprise assistant.
  
Your role:
- Help with customer inquiries
- Process orders and payments
- Provide product information

Communication:
- Professional and efficient
- Clear and accurate
- Proactive and helpful`,

  
  skills: [customerServiceSkill, productSkill],
  webhooks: [paymentWebhook],
  jobs: [dailyReportJob],
  preProcessors: [profanityFilter],
  postProcessors: [addDisclaimer]
});

import { LuaTool, LuaSkill, env } from 'lua-cli';
import { z } from 'zod';

class GetCustomerTool implements LuaTool {
  name = "get_customer";
  description = "Look up customer in your CRM";
  inputSchema = z.object({ 
    email: z.string().email() 
  });

  async execute(input: { email: string }) {
    // Call YOUR CRM API
    const response = await fetch(
      `https://your-crm.com/api/customers/${input.email}`,
      {
        headers: { 
          'X-API-Key': env('YOUR_CRM_API_KEY'),
          'Content-Type': 'application/json'
        }
      }
    );
    
    if (!response.ok) {
      throw new Error('Customer not found');
    }
    
    return await response.json();
  }
}

class CreateTicketTool implements LuaTool {
  name = "create_ticket";
  description = "Create support ticket in your system";
  inputSchema = z.object({
    customerId: z.string(),
    subject: z.string(),
    description: z.string()
  });

  async execute(input) {
    const response = await fetch('https://your-crm.com/api/tickets', {
      method: 'POST',
      headers: {
        'X-API-Key': env('YOUR_CRM_API_KEY'),
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(input)
    });
    
    return await response.json();
  }
}

const crmSkill = new LuaSkill({
  name: "crm-integration",
  description: "Access our CRM system for customer support",
  tools: [new GetCustomerTool(), new CreateTicketTool()]
});

// Configure agent (v3.0.0)
export const agent = new LuaAgent({
  name: "crm-support-agent",
  persona: "You are a customer support specialist. Help users by looking up their information and creating support tickets when needed.",
  skills: [crmSkill]
});

import { LuaAgent, LuaTool, LuaSkill, Products, Baskets } from 'lua-cli';
import { z } from 'zod';

class ShopAssistantTool implements LuaTool {
  name = "add_to_cart";
  description = "Add product to shopping cart";
  inputSchema = z.object({
    productId: z.string(),
    quantity: z.number().min(1)
  });
  
  async execute(input: { productId: string; quantity: number }) {
    // Use Platform APIs
    const product = await Products.getById(input.productId);
    const basket = await Baskets.create({ currency: 'USD' });
    
    await Baskets.addItem(basket.id, {
      id: input.productId,
      price: product.price,
      quantity: input.quantity
    });
    
    return { 
      basketId: basket.id,
      product: product.name,
      quantity: input.quantity,
      total: product.price * input.quantity
    };
  }
}

const shopSkill = new LuaSkill({
  name: "shop-assistant",
  description: "Help users shop and add items to cart",
  tools: [new ShopAssistantTool()]
});

// Configure agent (v3.0.0)
export const agent = new LuaAgent({
  name: "shop-assistant",
  persona: "You are a friendly shopping assistant. Help users find products and add them to their cart.",
  skills: [shopSkill]
});

import { LuaAgent, LuaSkill, LuaTool, Data, env } from 'lua-cli';
import { z } from 'zod';

class CompleteSearchTool implements LuaTool {
  name = "smart_search";
  description = "Search across all data sources intelligently";
  inputSchema = z.object({
    query: z.string(),
    userId: z.string().optional()
  });
  
  async execute(input: { query: string; userId?: string }) {
    // 1. Search YOUR product API/database
    const yourProducts = await fetch('https://your-api.com/search', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${env('YOUR_API_KEY')}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ query: input.query })
    }).then(r => r.json());
    
    // 2. Use Platform vector search for FAQs and documentation
    const faqResults = await Data.search('faqs', input.query, 5, 0.7);
    
    // 3. If user provided, get their purchase history from YOUR system
    let userHistory = null;
    if (input.userId) {
      userHistory = await fetch(
        `https://your-api.com/users/${input.userId}/purchases`,
        {
          headers: { 'Authorization': `Bearer ${env('YOUR_API_KEY')}` }
        }
      ).then(r => r.json());
    }
    
    // 4. Combine and return all results
    return {
      products: yourProducts,
      faqs: faqResults.data,
      userHistory,
      message: `Found ${yourProducts.length} products and ${faqResults.count} help articles`
    };
  }
}

const hybridSkill = new LuaSkill({
  name: "hybrid-search",
  description: "Search across all your systems and our platform",
  tools: [new CompleteSearchTool()]
});

// Configure agent (v3.0.0)
export const agent = new LuaAgent({
  name: "hybrid-assistant",
  persona: "You are a comprehensive search assistant. Help users find information across products, FAQs, and their history.",
  skills: [hybridSkill]
});

# Local development with live reload
lua chat

# Test specific tools with exact inputs
lua test

# Push your code to the cloud
lua push

# Deploy to production
lua deploy

# Or combine push and deploy
lua push && lua deploy

import { env } from 'lua-cli';

const apiKey = env('YOUR_API_KEY');
const dbPassword = env('DATABASE_PASSWORD');

lua env set YOUR_API_KEY "your-key-here"

class SafeTool implements LuaTool {
  async execute(input) {
    try {
      const response = await fetch('https://api.example.com/data');
      
      if (!response.ok) {
        throw new Error(`API error: ${response.status}`);
      }
      
      return await response.json();
    } catch (error) {
      // Log error for debugging
      console.error('Tool execution failed:', error);
      
      // Return user-friendly message
      return {
        error: true,
        message: 'Sorry, I encountered an issue. Please try again.'
      };
    }
  }
}

import { z } from 'zod';

class ValidatedTool implements LuaTool {
  inputSchema = z.object({
    email: z.string().email(),
    amount: z.number().positive(),
    date: z.string().datetime()
  });
  
  async execute(input) {
    // Input is guaranteed to match schema
    // TypeScript knows the types
  }
}