lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/api/webhook.api.service.js

@@ -0,0 +1,134 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * Webhook API Service
+ * Handles all webhook-related API calls
+ */
+export default class WebhookApi extends HttpClient {
+    /**
+     * Creates an instance of WebhookApi
+     * @param baseUrl - The base URL for the API
+     * @param apiKey - The API key for authentication
+     * @param agentId - The unique identifier of the agent
+     */
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Retrieves all webhooks for the agent
+     * @returns Promise resolving to an ApiResponse containing an array of webhooks with their versions
+     * @throws Error if the API request fails or the agent is not found
+     */
+    async getWebhooks() {
+        return this.httpGet(`/developer/webhooks/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Creates a new webhook for the agent
+     * @param webhookData - The webhook data including name, description, and optional context
+     * @returns Promise resolving to an ApiResponse containing the created webhook details
+     * @throws Error if the webhook creation fails or validation errors occur
+     */
+    async createWebhook(webhookData) {
+        return this.httpPost(`/developer/webhooks/${this.agentId}`, webhookData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Pushes a new version of a webhook to production
+     * @param webhookId - The unique identifier of the webhook
+     * @param versionData - The version data including code, configuration, and metadata
+     * @returns Promise resolving to an ApiResponse containing the created version details
+     * @throws Error if the webhook is not found or the push operation fails
+     */
+    async pushWebhook(webhookId, versionData) {
+        return this.httpPost(`/developer/webhooks/${this.agentId}/${webhookId}/version`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Pushes a new development/sandbox version of a webhook for testing
+     * @param webhookId - The unique identifier of the webhook
+     * @param versionData - The version data including code, configuration, and metadata
+     * @returns Promise resolving to an ApiResponse containing the development version details
+     * @throws Error if the webhook is not found or the push operation fails
+     */
+    async pushDevWebhook(webhookId, versionData) {
+        return this.httpPost(`/developer/webhooks/${this.agentId}/${webhookId}/version/sandbox`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates an existing development/sandbox version of a webhook
+     * @param webhookId - The unique identifier of the webhook
+     * @param sandboxVersionId - The unique identifier of the sandbox version to update
+     * @param versionData - The updated version data including code, configuration, and metadata
+     * @returns Promise resolving to an ApiResponse containing the updated version details
+     * @throws Error if the webhook or version is not found or the update fails
+     */
+    async updateDevWebhook(webhookId, sandboxVersionId, versionData) {
+        return this.httpPut(`/developer/webhooks/${this.agentId}/${webhookId}/version/sandbox/${sandboxVersionId}`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Retrieves all versions of a specific webhook
+     * @param webhookId - The unique identifier of the webhook
+     * @returns Promise resolving to an ApiResponse containing an array of webhook versions
+     * @throws Error if the webhook is not found or the request fails
+     */
+    async getWebhookVersions(webhookId) {
+        return this.httpGet(`/developer/webhooks/${this.agentId}/${webhookId}/versions`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Publishes a specific version of a webhook to production
+     * @param webhookId - The unique identifier of the webhook
+     * @param version - The version identifier to publish
+     * @returns Promise resolving to an ApiResponse containing publication confirmation details
+     * @throws Error if the webhook or version is not found or the publish operation fails
+     */
+    async publishWebhookVersion(webhookId, version) {
+        return this.httpPut(`/developer/webhooks/${this.agentId}/${webhookId}/${version}/publish`, undefined, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Activates a webhook (enables it to receive requests)
+     * @param webhookId - The unique identifier of the webhook to activate
+     * @returns Promise resolving to an ApiResponse with activation status
+     * @throws Error if the webhook is not found or the operation fails
+     */
+    async activateWebhook(webhookId) {
+        return this.httpPost(`/developer/webhooks/${this.agentId}/${webhookId}/activate`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deactivates a webhook (stops it from receiving requests)
+     * @param webhookId - The unique identifier of the webhook to deactivate
+     * @returns Promise resolving to an ApiResponse with deactivation status
+     * @throws Error if the webhook is not found or the operation fails
+     */
+    async deactivateWebhook(webhookId) {
+        return this.httpPost(`/developer/webhooks/${this.agentId}/${webhookId}/deactivate`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deletes a webhook and all its versions, or deactivates it if it has versions
+     * @param webhookId - The unique identifier of the webhook to delete
+     * @returns Promise resolving to an ApiResponse with deletion status
+     *   - If deleted is true: webhook was successfully deleted
+     *   - If deleted is false and deactivated is true: webhook has versions and was deactivated instead
+     * @throws Error if the webhook is not found or the delete operation fails
+     */
+    async deleteWebhook(webhookId) {
+        return this.httpDelete(`/developer/webhooks/${this.agentId}/${webhookId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

package/dist/api-exports.d.ts

@@ -26,20 +26,42 @@
  * const products = await Products.search('laptop');
  * ```
  */
-import { LuaSkill, LuaTool, env } from "./types/skill.js";
-import { BasketStatus } from "./interfaces/baskets.js";
-import { OrderStatus } from "./interfaces/orders.js";
-/**
- * User Data API
- * Access user information and preferences
- */
+import { LuaSkill, LuaTool, LuaWebhook, LuaWebhookConfig, LuaJob, LuaJobConfig, JobSchedule, PreProcessor, PreProcessorConfig, PostProcessor, PostProcessorConfig, LuaAgent, LuaAgentConfig, env } from "./types/skill.js";
+import { Basket, BasketStatus, UpdateBasketMetadataResponse } from "./interfaces/baskets.js";
+import { OrderResponse, OrderStatus } from "./interfaces/orders.js";
+import { ChatHistoryMessage, ChatHistoryContent } from "./interfaces/chat.js";
+import { JobInstance } from "./common/job.instance.js";
+import { DeleteProductResponse, Product } from "./interfaces/product.js";
+import ProductInstance from "./common/product.instance.js";
+import ProductPaginationInstance from "./common/product.pagination.instance.js";
+import ProductSearchInstance from "./common/product.search.instance.js";
+import DataEntryInstance from "./common/data.entry.instance.js";
+import { DeleteCustomDataResponse, GetCustomDataResponse, UpdateCustomDataResponse } from "./interfaces/custom.data.js";
+import UserDataInstance from "./common/user.instance.js";
+import BasketInstance from "./common/basket.instance.js";
+import OrderInstance from "./common/order.instance.js";
 export declare const User: {
     /**
      * Retrieves current user data.
      *
      * @returns Promise resolving to user data
      */
-    get(): Promise<import("./common/user.instance.js").default>;
+    get(): Promise<UserDataInstance>;
+    /**
+     * Gets the chat history for the current user.
+     *
+     * @returns Promise resolving to array of chat messages
+     *
+     * @example
+     * ```typescript
+     * const history = await User.getChatHistory();
+     * // Returns: [
+     * //   { role: 'user', content: [{type: 'text', text: 'hello'}], createdAt: '...', id: '...', threadId: '...' },
+     * //   { role: 'assistant', content: [{type: 'text', text: 'hi'}], createdAt: '...', id: '...', threadId: '...' }
+     * // ]
+     * ```
+     */
+    getChatHistory(): Promise<import("./interfaces/chat.js").ChatHistoryMessage[]>;
 };
 /**
  * Custom Data API
@@ -54,7 +76,7 @@ export declare const Data: {
      * @param searchText - Optional text for vector search indexing
      * @returns Promise resolving to created entry
      */
-    create(collectionName: string, data: any, searchText?: string): Promise<import("./common/data.entry.instance.js").default>;
+    create(collectionName: string, data: any, searchText?: string): Promise<DataEntryInstance>;
     /**
      * Retrieves entries from a collection with optional filtering and pagination.
      *
@@ -64,7 +86,7 @@ export declare const Data: {
      * @param limit - Items per page (default: 10)
      * @returns Promise resolving to array of entries
      */
-    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<import("./interfaces/custom.data.js").GetCustomDataResponse>;
+    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<GetCustomDataResponse>;
     /**
      * Retrieves a specific entry by ID.
      *
@@ -72,7 +94,7 @@ export declare const Data: {
      * @param entryId - ID of the entry
      * @returns Promise resolving to entry data
      */
-    getEntry(collectionName: string, entryId: string): Promise<import("./common/data.entry.instance.js").default>;
+    getEntry(collectionName: string, entryId: string): Promise<DataEntryInstance>;
     /**
      * Updates an existing entry.
      *
@@ -81,7 +103,7 @@ export declare const Data: {
      * @param data - Updated data
      * @returns Promise resolving to updated entry
      */
-    update(collectionName: string, entryId: string, data: any): Promise<import("./interfaces/custom.data.js").UpdateCustomDataResponse>;
+    update(collectionName: string, entryId: string, data: any): Promise<UpdateCustomDataResponse>;
     /**
      * Performs vector search on a collection.
      *
@@ -91,7 +113,7 @@ export declare const Data: {
      * @param scoreThreshold - Minimum similarity score (0-1)
      * @returns Promise resolving to search results
      */
-    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<import("./common/data.entry.instance.js").default[]>;
+    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<DataEntryInstance[]>;
     /**
      * Deletes an entry from a collection.
      *
@@ -99,7 +121,7 @@ export declare const Data: {
      * @param entryId - ID of the entry to delete
      * @returns Promise resolving when deletion is complete
      */
-    delete(collectionName: string, entryId: string): Promise<import("./interfaces/custom.data.js").DeleteCustomDataResponse>;
+    delete(collectionName: string, entryId: string): Promise<DeleteCustomDataResponse>;
 };
 /**
  * Products API
@@ -113,43 +135,35 @@ export declare const Products: {
      * @param page - Page number
      * @returns Promise resolving to product list
      */
-    get(limit?: number, page?: number): Promise<import("./common/product.pagination.instance.js").default>;
+    get(limit?: number, page?: number): Promise<ProductPaginationInstance>;
     /**
      * Creates a new product.
      *
      * @param product - Product data
      * @returns Promise resolving to created product
      */
-    create(product: any): Promise<import("./common/product.instance.js").default>;
-    /**
-     * Updates an existing product.
-     *
-     * @param data - Updated product data
-     * @param id - Product ID
-     * @returns Promise resolving to updated product
-     */
-    update(data: any, id: string): Promise<import("./interfaces/product.js").UpdateProductResponse>;
+    create(product: Product): Promise<ProductInstance>;
     /**
      * Deletes a product.
      *
      * @param id - Product ID
      * @returns Promise resolving when deletion is complete
      */
-    delete(id: string): Promise<import("./interfaces/product.js").DeleteProductResponse>;
+    delete(id: string): Promise<DeleteProductResponse>;
     /**
      * Searches products by query string.
      *
      * @param query - Search query
      * @returns Promise resolving to search results
      */
-    search(query: string): Promise<import("./common/product.search.instance.js").default>;
+    search(query: string): Promise<ProductSearchInstance>;
     /**
      * Retrieves a specific product by ID.
      *
      * @param id - Product ID
      * @returns Promise resolving to product data
      */
-    getById(id: string): Promise<import("./common/product.instance.js").default>;
+    getById(id: string): Promise<ProductInstance>;
 };
 /**
  * Baskets API
@@ -162,14 +176,14 @@ export declare const Baskets: {
      * @param basketData - Basket initialization data
      * @returns Promise resolving to created basket
      */
-    create(basketData: any): Promise<import("./common/basket.instance.js").default>;
+    create(basketData: any): Promise<BasketInstance>;
     /**
      * Retrieves baskets, optionally filtered by status.
      *
      * @param status - Optional basket status filter
      * @returns Promise resolving to basket list
      */
-    get(status?: any): Promise<import("./common/basket.instance.js").default[]>;
+    get(status?: any): Promise<BasketInstance[]>;
     /**
      * Adds an item to a basket.
      *
@@ -177,7 +191,7 @@ export declare const Baskets: {
      * @param itemData - Item data to add
      * @returns Promise resolving to updated basket
      */
-    addItem(basketId: string, itemData: any): Promise<import("./interfaces/baskets.js").Basket>;
+    addItem(basketId: string, itemData: any): Promise<Basket>;
     /**
      * Removes an item from a basket.
      *
@@ -185,14 +199,14 @@ export declare const Baskets: {
      * @param itemId - Item ID to remove
      * @returns Promise resolving to updated basket
      */
-    removeItem(basketId: string, itemId: string): Promise<import("./interfaces/baskets.js").Basket>;
+    removeItem(basketId: string, itemId: string): Promise<Basket>;
     /**
      * Clears all items from a basket.
      *
      * @param basketId - Basket ID
      * @returns Promise resolving to cleared basket
      */
-    clear(basketId: string): Promise<import("./interfaces/baskets.js").Basket>;
+    clear(basketId: string): Promise<Basket>;
     /**
      * Updates basket status.
      *
@@ -208,7 +222,7 @@ export declare const Baskets: {
      * @param metadata - Metadata to update
      * @returns Promise resolving to updated basket
      */
-    updateMetadata(basketId: string, metadata: any): Promise<import("./interfaces/baskets.js").UpdateBasketMetadataResponse>;
+    updateMetadata(basketId: string, metadata: any): Promise<UpdateBasketMetadataResponse>;
     /**
      * Converts basket to order.
      *
@@ -216,14 +230,14 @@ export declare const Baskets: {
      * @param basketId - Basket ID to convert
      * @returns Promise resolving to created order
      */
-    placeOrder(data: Record<string, any>, basketId: string): Promise<import("./common/order.instance.js").default>;
+    placeOrder(data: Record<string, any>, basketId: string): Promise<OrderInstance>;
     /**
      * Retrieves a specific basket by ID.
      *
      * @param basketId - Basket ID
      * @returns Promise resolving to basket data
      */
-    getById(basketId: string): Promise<import("./common/basket.instance.js").default>;
+    getById(basketId: string): Promise<BasketInstance>;
 };
 /**
  * Orders API
@@ -236,7 +250,7 @@ export declare const Orders: {
      * @param orderData - Order data
      * @returns Promise resolving to created order
      */
-    create(orderData: any): Promise<import("./common/order.instance.js").default>;
+    create(orderData: any): Promise<OrderInstance>;
     /**
      * Updates order status.
      *
@@ -244,7 +258,7 @@ export declare const Orders: {
      * @param orderId - Order ID
      * @returns Promise resolving to updated order
      */
-    updateStatus(status: any, orderId: string): Promise<import("./interfaces/orders.js").OrderResponse>;
+    updateStatus(status: any, orderId: string): Promise<OrderResponse>;
     /**
      * Updates order data.
      *
@@ -252,20 +266,121 @@ export declare const Orders: {
      * @param orderId - Order ID
      * @returns Promise resolving to updated order
      */
-    updateData(data: Record<string, any>, orderId: string): Promise<import("./interfaces/orders.js").OrderResponse>;
+    updateData(data: Record<string, any>, orderId: string): Promise<OrderResponse>;
     /**
      * Retrieves orders, optionally filtered by status.
      *
      * @param status - Optional order status filter
      * @returns Promise resolving to order list
      */
-    get(status?: any): Promise<import("./common/order.instance.js").default[]>;
+    get(status?: any): Promise<OrderInstance[]>;
     /**
      * Retrieves a specific order by ID.
      *
      * @param orderId - Order ID
      * @returns Promise resolving to order data
      */
-    getById(orderId: string): Promise<import("./common/order.instance.js").default>;
+    getById(orderId: string): Promise<OrderInstance>;
+};
+/**
+ * Jobs API
+ * Manage and trigger scheduled jobs from within your tools
+ */
+export declare const Jobs: {
+    /**
+     * Creates a new job dynamically from within a tool.
+     * This allows tools to schedule one-time or recurring jobs programmatically.
+     *
+     * @param config - Job configuration
+     * @param config.name - Unique job name
+     * @param config.description - Job description
+     * @param config.schedule - Schedule configuration (cron, once, or interval)
+     * @param config.execute - Async function to execute
+     * @param config.timeout - Optional timeout in seconds
+     * @param config.retry - Optional retry configuration
+     * @returns Promise resolving to created job details
+     *
+     * @example
+     * ```typescript
+     * // Create a one-time job to check basket in 3 hours
+     * await Jobs.create({
+     *   name: `check-basket-${basketId}`,
+     *   description: 'Check if basket was abandoned',
+     *   schedule: {
+     *     type: 'once',
+     *     executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000)
+     *   },
+     *   execute: async () => {
+     *     const basket = await Baskets.getById(basketId);
+     *     if (basket.status === 'active') {
+     *       // Send reminder
+     *     }
+     *     return { checked: true };
+     *   }
+     * });
+     * ```
+     */
+    create(config: {
+        name: string;
+        description?: string;
+        schedule: any;
+        execute: (job: JobInstance) => Promise<any>;
+        timeout?: number;
+        retry?: {
+            maxAttempts: number;
+            backoffSeconds?: number;
+        };
+        metadata?: Record<string, any>;
+    }): Promise<JobInstance>;
+    /**
+     * Retrieves a job by its unique identifier
+     * @param jobId - The unique identifier of the job to retrieve
+     * @returns Promise resolving to an JobInstance representing the job
+     * @throws Error if the job is not found or the request fails
+     */
+    getJob(jobId: string): Promise<JobInstance>;
+};
+/**
+ * AI API
+ * Generate AI responses with custom context
+ */
+export declare const AI: {
+    /**
+     * Generates an AI response with custom runtime context.
+     *
+     * @param context - Runtime context to provide to the AI
+     * @param messages - Array of messages (text, image, file, etc.)
+     * @param agentId - Optional agent ID to use (defaults to current agent)
+     * @returns Promise resolving to AI response text
+     *
+     * @example
+     * ```typescript
+     * // Simple text message with current agent
+     * const response = await AI.generate(
+     *   'You are a helpful sales assistant for our e-commerce store.',
+     *   [{ type: 'text', text: 'What products do you recommend for beginners?' }]
+     * );
+     * console.log(response); // AI-generated recommendation
+     *
+     * // Multiple messages with images
+     * const response2 = await AI.generate(
+     *   'You are an image analysis expert.',
+     *   [
+     *     { type: 'text', text: 'What do you see in this image?' },
+     *     { type: 'image', url: 'https://example.com/image.jpg' }
+     *   ]
+     * );
+     *
+     * // Use a different agent
+     * const response3 = await AI.generate(
+     *   'You are a specialized assistant.',
+     *   [{ type: 'text', text: 'Help me with this task' }],
+     *   'agent_different_123'
+     * );
+     * ```
+     */
+    generate(context: string, messages: import("./interfaces/chat.js").ChatMessage[], agentId?: string): Promise<string>;
 };
-export { LuaSkill, LuaTool, BasketStatus, OrderStatus, env };
+export { LuaSkill, LuaTool, LuaWebhook, LuaWebhookConfig, LuaJob, LuaJobConfig, JobSchedule, PreProcessor, PreProcessorConfig, PostProcessor, PostProcessorConfig, LuaAgent, LuaAgentConfig, BasketStatus, OrderStatus, env };
+export { JobInstance };
+export { ChatHistoryMessage, ChatHistoryContent };