E-commerce shopping agent

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

export default class SearchProductsTool implements LuaTool {
  name = 'search_products';
  description = 'Find products in the catalog from a description of what the customer wants';

  inputSchema = z.object({
    query: z.string().describe('What the customer is looking for, for example "running shoes"'),
    maxPrice: z.number().positive().optional().describe('Only return products at or under this price'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const { products } = await Products.search(input.query);
    const max = input.maxPrice;
    const matches = max === undefined ? products : products.filter((p) => Number(p.data.price) <= max);

    return {
      products: matches.map((p) => ({
        id: p.data.id,
        name: p.data.name,
        price: p.data.price,
        inStock: p.data.inStock,
      })),
      total: matches.length,
    };
  }
}

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

export default class AddToCartTool implements LuaTool {
  name = 'add_to_cart';
  description = "Add a product to the customer's cart, creating the cart if they have none";

  inputSchema = z.object({
    productId: z.string().describe('The product id returned by search_products'),
    quantity: z.number().int().min(1).default(1),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const product = await Products.getById(input.productId);
    if (!product.data.inStock) {
      return { added: false, reason: `${product.data.name} is out of stock` };
    }

    // Baskets belong to the end user in the conversation, so no basket id passes through the model.
    const [open] = await Baskets.get(BasketStatus.ACTIVE);
    const basket = open ?? (await Baskets.create({ currency: 'USD' }));
    const basketId: string = basket.toJSON().id;

    const updated = await Baskets.addItem(basketId, {
      id: product.data.id,
      price: Number(product.data.price),
      quantity: input.quantity,
      SKU: product.data.sku,
    });

    return {
      added: true,
      item: product.data.name,
      itemCount: updated.common.itemCount,
      subtotal: updated.common.totalAmount,
    };
  }
}

import { LuaTool, Baskets, BasketStatus } from 'lua-cli';
import { z } from 'zod';

export default class CheckoutTool implements LuaTool {
  name = 'checkout';
  description =
    'Place an order for everything in the cart. Read the items and total back to the customer and confirm the address first.';

  inputSchema = z.object({
    shippingAddress: z.object({
      name: z.string(),
      line1: z.string(),
      city: z.string(),
      postalCode: z.string(),
      country: z.string().length(2).describe('ISO 3166-1 alpha-2, for example "US"'),
    }),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const [basket] = await Baskets.get(BasketStatus.ACTIVE);
    if (!basket || basket.itemCount === 0) {
      return { placed: false, reason: 'The cart is empty' };
    }

    const items = (basket.items ?? []) as Array<{ id: string; price: number; quantity: number }>;
    const order = await basket.placeOrder({ shippingAddress: input.shippingAddress });
    const placed = order.toJSON();

    return {
      placed: true,
      orderId: placed.orderId,
      items: items.map((item) => ({ productId: item.id, quantity: item.quantity })),
      total: basket.totalAmount,
    };
  }
}

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

export default class TrackOrderTool implements LuaTool {
  name = 'track_order';
  description = "Report the status of one of the customer's orders";

  inputSchema = z.object({
    orderId: z.string().describe('The order id returned by checkout'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    // Orders are scoped to the end user, so a customer can only read their own.
    const order = await Orders.getById(input.orderId);
    const o = order.toJSON();

    return {
      orderId: input.orderId,
      status: o.status,
      itemCount: o.itemCount,
      total: o.totalAmount,
      placedAt: o.orderDate,
    };
  }
}

import { LuaSkill } from 'lua-cli';
import SearchProductsTool from './tools/SearchProductsTool';
import AddToCartTool from './tools/AddToCartTool';
import CheckoutTool from './tools/CheckoutTool';
import TrackOrderTool from './tools/TrackOrderTool';

export default new LuaSkill({
  name: 'shopping',
  description: 'Search the catalog, manage the cart, check out, and track orders',
  context: `Use search_products for anything the customer describes, then add_to_cart with the
product id they choose. Before checkout, read back every item, the quantity, and the total,
and ask for the shipping address. Call checkout only after the customer says yes.
Use track_order when they ask where an order is.`,
  tools: [new SearchProductsTool(), new AddToCartTool(), new CheckoutTool(), new TrackOrderTool()],
});

import { LuaAgent } from 'lua-cli';
import shoppingSkill from './skills/shopping.skill';

const agent = new LuaAgent({
  name: 'acme-shop',
  persona: `You are the shopping assistant for the Acme store.
Help customers find products, build a cart, and check out. Always state prices and stock,
confirm every item and the total before placing an order, and never place an order the
customer has not explicitly approved.`,
  skills: [shoppingSkill],
});

✅ Compiled 6 primitives (1 agent, 1 skill, 4 tools) in 526ms
✅ Selected tool: search_products
Input: {
  "query": "lamp"
}
🚀 Executing tool...
✅ Tool execution successful!

Tool returned: Object — fields: products, total
Output:
{ products: [], total: 0 }