lua-cli 3.12.2 → 3.14.0

package/template/examples/skills/tools/GetWeatherTool.ts

@@ -1,53 +1,51 @@
-import { LuaTool } from "lua-cli";
-import { z } from "zod";
+import { LuaTool } from 'lua-cli';
+import { z } from 'zod';
 
 export default class GetWeatherTool implements LuaTool {
-    name = "get_weather";
-    description = "Get the weather for a given city";
-    inputSchema = z.object({
-        city: z.string()
-    });
-    outputSchema = z.object({
-        weather: z.string(),
-        city: z.string(),
-        temperature: z.number().optional(),
-        humidity: z.number().optional(),
-        description: z.string().optional()
-    });
+  name = 'get_weather';
+  description = 'Get the weather for a given city';
+  inputSchema = z.object({
+    city: z.string(),
+  });
+  outputSchema = z.object({
+    weather: z.string(),
+    city: z.string(),
+    temperature: z.number().optional(),
+    humidity: z.number().optional(),
+    description: z.string().optional(),
+  });
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        // Step 1: Geocode city → lat/lon (use Open-Meteo’s free geocoding API)
-        const geoUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(
-            input.city
-        )}&count=1`;
-        
-        const geoRes = await fetch(geoUrl);
-        if (!geoRes.ok) {
-            throw new Error(`Failed to fetch location: ${geoRes.statusText}`);
-        }
-        const geoData = await geoRes.json();
-        if (!geoData.results || geoData.results.length === 0) {
-            throw new Error(`No location found for ${input.city}`);
-        }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    // Step 1: Geocode city → lat/lon (use Open-Meteo’s free geocoding API)
+    const geoUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(input.city)}&count=1`;
 
-        const { latitude, longitude, name } = geoData.results[0];
+    const geoRes = await fetch(geoUrl);
+    if (!geoRes.ok) {
+      throw new Error(`Failed to fetch location: ${geoRes.statusText}`);
+    }
+    const geoData = await geoRes.json();
+    if (!geoData.results || geoData.results.length === 0) {
+      throw new Error(`No location found for ${input.city}`);
+    }
 
-        // Step 2: Get weather for lat/lon
-        const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current_weather=true`;
-        
-        const weatherRes = await fetch(weatherUrl);
-        if (!weatherRes.ok) {
-            throw new Error(`Failed to fetch weather: ${weatherRes.statusText}`);
-        }
-        const weatherData = await weatherRes.json();
-        const current = weatherData.current_weather;
+    const { latitude, longitude, name } = geoData.results[0];
 
-        return {
-            weather: current.weathercode?.toString() || "Unknown",
-            city: name,
-            temperature: current.temperature,
-            humidity: undefined, // Open-Meteo current_weather does not include humidity
-            description: `Windspeed ${current.windspeed} km/h`
-        };
+    // Step 2: Get weather for lat/lon
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current_weather=true`;
+
+    const weatherRes = await fetch(weatherUrl);
+    if (!weatherRes.ok) {
+      throw new Error(`Failed to fetch weather: ${weatherRes.statusText}`);
     }
+    const weatherData = await weatherRes.json();
+    const current = weatherData.current_weather;
+
+    return {
+      weather: current.weathercode?.toString() || 'Unknown',
+      city: name,
+      temperature: current.temperature,
+      humidity: undefined, // Open-Meteo current_weather does not include humidity
+      description: `Windspeed ${current.windspeed} km/h`,
+    };
+  }
 }

package/template/examples/skills/tools/OrderTool.ts

@@ -1,56 +1,56 @@
-import { LuaTool, Orders, } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Orders } from 'lua-cli';
+import { z } from 'zod';
 import { OrderStatus } from 'lua-cli';
 
-
-
 export class CreateOrderTool implements LuaTool {
-    name = "create_order";
-    description = "Create a new order";
-    inputSchema = z.object({
-        order: z.object({
-            basketId: z.string(),
-            data: z.object({
-                storeId: z.string(),
-            }).optional()
+  name = 'create_order';
+  description = 'Create a new order';
+  inputSchema = z.object({
+    order: z.object({
+      basketId: z.string(),
+      data: z
+        .object({
+          storeId: z.string(),
         })
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Orders.create(input.order);
-    }
+        .optional(),
+    }),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Orders.create(input.order);
+  }
 }
 
 export class UpdateOrderStatusTool implements LuaTool {
-    name = "update_order_status";
-    description = "Update the status of an order";
-    inputSchema = z.object({
-        orderId: z.string(),
-        status: z.enum(['pending', 'confirmed', 'fulfilled', 'cancelled'])
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const order = await Orders.getById(input.orderId);
-        return order.updateStatus(input.status as OrderStatus);
-    }
+  name = 'update_order_status';
+  description = 'Update the status of an order';
+  inputSchema = z.object({
+    orderId: z.string(),
+    status: z.enum(['pending', 'confirmed', 'fulfilled', 'cancelled']),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const order = await Orders.getById(input.orderId);
+    return order.updateStatus(input.status as OrderStatus);
+  }
 }
 
 export class GetUserOrdersTool implements LuaTool {
-    name = "get_user_orders";
-    description = "Get all orders for a user";
-    inputSchema = z.object({});
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Orders.get();
-    }
+  name = 'get_user_orders';
+  description = 'Get all orders for a user';
+  inputSchema = z.object({});
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Orders.get();
+  }
 }
 
 export class GetOrderByIdTool implements LuaTool {
-    name = "get_order_by_id";
-    description = "Get an order by id";
-    inputSchema = z.object({
-        orderId: z.string()
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        return Orders.getById(input.orderId);
-    }
+  name = 'get_order_by_id';
+  description = 'Get an order by id';
+  inputSchema = z.object({
+    orderId: z.string(),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    return Orders.getById(input.orderId);
+  }
 }
 
 /**
@@ -58,22 +58,22 @@ export class GetOrderByIdTool implements LuaTool {
  * Useful for adding tracking info, notes, or custom metadata.
  */
 export class UpdateOrderDataTool implements LuaTool {
-    name = "update_order_data";
-    description = "Update custom data on an order (tracking info, notes, etc.)";
-    inputSchema = z.object({
-        orderId: z.string().describe("The order ID to update"),
-        data: z.record(z.any()).describe("Custom data to add/update on the order")
-    });
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        console.log(`📝 Updating order ${input.orderId} with data:`, input.data);
-        
-        const result = await Orders.updateData(input.data, input.orderId);
-        
-        return {
-            success: true,
-            orderId: input.orderId,
-            message: "Order data updated successfully",
-            updatedData: input.data
-        };
-    }
+  name = 'update_order_data';
+  description = 'Update custom data on an order (tracking info, notes, etc.)';
+  inputSchema = z.object({
+    orderId: z.string().describe('The order ID to update'),
+    data: z.record(z.any()).describe('Custom data to add/update on the order'),
+  });
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    console.log(`📝 Updating order ${input.orderId} with data:`, input.data);
+
+    const result = await Orders.updateData(input.data, input.orderId);
+
+    return {
+      success: true,
+      orderId: input.orderId,
+      message: 'Order data updated successfully',
+      updatedData: input.data,
+    };
+  }
 }

package/template/examples/skills/tools/PaymentTool.ts

@@ -1,51 +1,51 @@
-import { LuaTool, env } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, env } from 'lua-cli';
+import { z } from 'zod';
 
 export default class CreatePaymentLinkTool implements LuaTool {
-    name = "create_payment_link";
-    description = "Create a Stripe payment link for a one-time payment";
-    inputSchema = z.object({
-        amount: z.number().int().positive(), // in cents
-        currency: z.string().default("usd")
-    });
-    outputSchema = z.object({
-        url: z.string(),
-        id: z.string(),
-    });
+  name = 'create_payment_link';
+  description = 'Create a Stripe payment link for a one-time payment';
+  inputSchema = z.object({
+    amount: z.number().int().positive(), // in cents
+    currency: z.string().default('usd'),
+  });
+  outputSchema = z.object({
+    url: z.string(),
+    id: z.string(),
+  });
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        const apiKey = env("STRIPE_SECRET_KEY");
-        if (!apiKey) {
-            throw new Error("STRIPE_SECRET_KEY is not set in environment variables");
-        }
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    const apiKey = env('STRIPE_SECRET_KEY');
+    if (!apiKey) {
+      throw new Error('STRIPE_SECRET_KEY is not set in environment variables');
+    }
 
-        // Create a one-time Checkout Session with dummy redirect URLs
-        const sessionRes = await fetch("https://api.stripe.com/v1/checkout/sessions", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
-            body: new URLSearchParams({
-                mode: "payment",
-                "line_items[0][price_data][currency]": input.currency,
-                "line_items[0][price_data][product_data][name]": "One-time Payment",
-                "line_items[0][price_data][unit_amount]": input.amount.toString(),
-                "line_items[0][quantity]": "1",
-                success_url: "https://example.com/success",
-                cancel_url: "https://example.com/cancel",
-            }),
-        });
+    // Create a one-time Checkout Session with dummy redirect URLs
+    const sessionRes = await fetch('https://api.stripe.com/v1/checkout/sessions', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams({
+        mode: 'payment',
+        'line_items[0][price_data][currency]': input.currency,
+        'line_items[0][price_data][product_data][name]': 'One-time Payment',
+        'line_items[0][price_data][unit_amount]': input.amount.toString(),
+        'line_items[0][quantity]': '1',
+        success_url: 'https://example.com/success',
+        cancel_url: 'https://example.com/cancel',
+      }),
+    });
 
-        if (!sessionRes.ok) {
-            throw new Error(`Failed to create checkout session: ${await sessionRes.text()}`);
-        }
+    if (!sessionRes.ok) {
+      throw new Error(`Failed to create checkout session: ${await sessionRes.text()}`);
+    }
 
-        const session = await sessionRes.json();
+    const session = await sessionRes.json();
 
-        return {
-            url: session.url,
-            id: session.id,
-        };
-    }
+    return {
+      url: session.url,
+      id: session.id,
+    };
+  }
 }

package/template/examples/skills/tools/PremiumFeatureTool.ts

@@ -1,98 +1,100 @@
-import { LuaTool, Products, User } from "lua-cli";
-import { z } from "zod";
+import { LuaTool, Products, User } from 'lua-cli';
+import { z } from 'zod';
 
 /**
  * Example tool with a condition.
- * 
+ *
  * The `condition` function determines if this tool should be available to the LLM.
  * It runs BEFORE the tool is offered, so the LLM won't see this tool if condition returns false.
- * 
+ *
  * Use cases:
  * - Premium/paid features only for subscribed users
  * - Features based on user verification status
  * - Region-specific tools
  * - A/B testing tool availability
  * - Time-based feature access
- * 
+ *
  * The condition has access to all Platform APIs: User, Data, Products, Baskets, Orders, etc.
  */
 export default class PremiumFeatureTool implements LuaTool {
-    name = "premium_advanced_search";
-    description = "Advanced search with filters and sorting - available to premium users only";
-    
-    inputSchema = z.object({
-        query: z.string().describe("Search query"),
-        filters: z.object({
-            category: z.string().optional().describe("Filter by category"),
-            minPrice: z.number().optional().describe("Minimum price filter"),
-            maxPrice: z.number().optional().describe("Maximum price filter"),
-        }).optional().describe("Optional filters"),
-        sortBy: z.enum(["relevance", "price_asc", "price_desc", "newest"]).optional().describe("Sort order")
-    });
+  name = 'premium_advanced_search';
+  description = 'Advanced search with filters and sorting - available to premium users only';
 
-    /**
-     * Condition function - determines if this tool should be available.
-     * 
-     * This runs once per request when tools are being built.
-     * Return true to enable the tool, false to hide it from the LLM.
-     * 
-     * If condition throws an error, the tool is disabled (fail-closed behavior).
-     */
-    condition = async () => {
-        // Get the current user's data
-        const user = await User.get();
-        
-        // Check if user has premium subscription
-        // The 'data' field contains custom user data stored via User.update()
-        const isPremium = user.data?.subscription === "premium" || user.data?.isPremium === true;
-        
-        // You can also check other conditions:
-        // - user.data?.trialEndsAt > Date.now() (trial period)
-        // - user.country?.code === "US" (region-based)
-        // - user.data?.featureFlags?.advancedSearch (feature flags)
-        
-        return isPremium;
-    };
+  inputSchema = z.object({
+    query: z.string().describe('Search query'),
+    filters: z
+      .object({
+        category: z.string().optional().describe('Filter by category'),
+        minPrice: z.number().optional().describe('Minimum price filter'),
+        maxPrice: z.number().optional().describe('Maximum price filter'),
+      })
+      .optional()
+      .describe('Optional filters'),
+    sortBy: z.enum(['relevance', 'price_asc', 'price_desc']).optional().describe('Sort order'),
+  });
+
+  /**
+   * Condition function - determines if this tool should be available.
+   *
+   * This runs once per request when tools are being built.
+   * Return true to enable the tool, false to hide it from the LLM.
+   *
+   * If condition throws an error, the tool is disabled (fail-closed behavior).
+   */
+  condition = async () => {
+    // Get the current user's data (returns null when called outside a conversation)
+    const user = await User.get();
+    if (!user) return false;
+
+    // Check if user has premium subscription
+    // The 'data' field contains custom user data stored via User.update()
+    const isPremium = user.data?.subscription === 'premium' || user.data?.isPremium === true;
+
+    // You can also check other conditions:
+    // - user.data?.trialEndsAt > Date.now() (trial period)
+    // - user.country?.code === "US" (region-based)
+    // - user.data?.featureFlags?.advancedSearch (feature flags)
+
+    return isPremium;
+  };
+
+  async execute(input: z.infer<typeof this.inputSchema>) {
+    // This only runs if condition returned true
+    const { query, filters, sortBy } = input;
+
+    // Products.search(query) — returns ProductSearchInstance (iterable, has .products)
+    const searchResult = await Products.search(query);
+    const products = searchResult.products;
 
-    async execute(input: z.infer<typeof this.inputSchema>) {
-        // This only runs if condition returned true
-        const { query, filters, sortBy } = input;
-        
-        // Example: Search products with advanced filters
-        const searchOptions: any = {
-            query,
-            limit: 20,
-        };
-        
-        if (filters?.category) {
-            searchOptions.category = filters.category;
-        }
-        
-        if (sortBy) {
-            searchOptions.sortBy = sortBy;
-        }
+    // Apply filters client-side
+    let filteredResults = products;
 
-        const searchResult = await Products.search(searchOptions);
-        const products = searchResult.products;
-        
-        // Apply price filters if provided
-        let filteredResults = products;
-        if (filters?.minPrice !== undefined || filters?.maxPrice !== undefined) {
-            filteredResults = products.filter((product) => {
-                const price = product.price || 0;
-                if (filters.minPrice !== undefined && price < filters.minPrice) return false;
-                if (filters.maxPrice !== undefined && price > filters.maxPrice) return false;
-                return true;
-            });
-        }
-        
-        return {
-            query,
-            totalResults: filteredResults.length,
-            results: filteredResults.slice(0, 10), // Return top 10
-            appliedFilters: filters,
-            sortedBy: sortBy || "relevance"
-        };
+    if (filters?.category) {
+      filteredResults = filteredResults.filter((p) => p.category === filters.category);
+    }
+
+    if (filters?.minPrice !== undefined || filters?.maxPrice !== undefined) {
+      filteredResults = filteredResults.filter((product) => {
+        const price = product.price || 0;
+        if (filters.minPrice !== undefined && price < filters.minPrice) return false;
+        if (filters.maxPrice !== undefined && price > filters.maxPrice) return false;
+        return true;
+      });
     }
-}
 
+    // Sort client-side when requested
+    if (sortBy === 'price_asc') {
+      filteredResults = [...filteredResults].sort((a, b) => (a.price || 0) - (b.price || 0));
+    } else if (sortBy === 'price_desc') {
+      filteredResults = [...filteredResults].sort((a, b) => (b.price || 0) - (a.price || 0));
+    }
+
+    return {
+      query,
+      totalResults: filteredResults.length,
+      results: filteredResults.slice(0, 10), // Return top 10
+      appliedFilters: filters,
+      sortedBy: sortBy || 'relevance',
+    };
+  }
+}