lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/api/postprocessor.api.service.d.ts

@@ -0,0 +1,98 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/common.js";
+/**
+ * PostProcessor API Response Types
+ */
+export interface PostProcessorVersion {
+    version: string;
+    postprocessorId: string;
+    createdAt: string | number;
+    isActive?: boolean;
+}
+export interface GetPostProcessorsResponse {
+    postprocessors: Array<{
+        id: string;
+        name: string;
+        description?: string;
+        context?: string;
+        versions: PostProcessorVersion[];
+        activeVersionId?: string;
+    }>;
+}
+export interface CreatePostProcessorResponse {
+    id: string;
+    name: string;
+    description?: string;
+    agentId: string;
+    context?: string;
+}
+export interface PostProcessorVersionResponse {
+    versionId: string;
+    postprocessorId: string;
+    version: string;
+    createdAt: string;
+}
+export interface DeletePostProcessorResponse {
+    deleted: boolean;
+    deactivated?: boolean;
+    message: string;
+}
+/**
+ * PostProcessor API Service
+ * Handles all postprocessor-related API calls
+ */
+export default class PostProcessorApi extends HttpClient {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Retrieves all postprocessors for the agent
+     */
+    getPostProcessors(): Promise<ApiResponse<GetPostProcessorsResponse>>;
+    /**
+     * Creates a new postprocessor for the agent
+     */
+    createPostProcessor(data: {
+        name: string;
+        description?: string;
+        context?: string;
+    }): Promise<ApiResponse<CreatePostProcessorResponse>>;
+    /**
+     * Pushes a new version of a postprocessor
+     */
+    pushPostProcessor(postprocessorId: string, versionData: any): Promise<ApiResponse<PostProcessorVersionResponse>>;
+    /**
+     * Retrieves all versions of a specific postprocessor
+     */
+    getPostProcessorVersions(postprocessorId: string): Promise<ApiResponse<{
+        versions: PostProcessorVersion[];
+        activeVersionId?: string;
+    }>>;
+    /**
+     * Publishes a specific version of a postprocessor to production
+     */
+    publishPostProcessorVersion(postprocessorId: string, version: string): Promise<ApiResponse<{
+        message: string;
+        postprocessorId: string;
+        activeVersionId: string;
+        publishedAt: string;
+    }>>;
+    /**
+     * Activates a postprocessor
+     */
+    activatePostProcessor(postprocessorId: string): Promise<ApiResponse<{
+        message: string;
+        active: boolean;
+    }>>;
+    /**
+     * Deactivates a postprocessor
+     */
+    deactivatePostProcessor(postprocessorId: string): Promise<ApiResponse<{
+        message: string;
+        active: boolean;
+    }>>;
+    /**
+     * Deletes a postprocessor
+     */
+    deletePostProcessor(postprocessorId: string): Promise<ApiResponse<DeletePostProcessorResponse>>;
+}

package/dist/api/postprocessor.api.service.js

@@ -0,0 +1,76 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * PostProcessor API Service
+ * Handles all postprocessor-related API calls
+ */
+export default class PostProcessorApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Retrieves all postprocessors for the agent
+     */
+    async getPostProcessors() {
+        return this.httpGet(`/developer/postprocessors/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Creates a new postprocessor for the agent
+     */
+    async createPostProcessor(data) {
+        return this.httpPost(`/developer/postprocessors/${this.agentId}`, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Pushes a new version of a postprocessor
+     */
+    async pushPostProcessor(postprocessorId, versionData) {
+        return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/version`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Retrieves all versions of a specific postprocessor
+     */
+    async getPostProcessorVersions(postprocessorId) {
+        return this.httpGet(`/developer/postprocessors/${this.agentId}/${postprocessorId}/versions`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Publishes a specific version of a postprocessor to production
+     */
+    async publishPostProcessorVersion(postprocessorId, version) {
+        return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/${version}/publish`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Activates a postprocessor
+     */
+    async activatePostProcessor(postprocessorId) {
+        return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/activate`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deactivates a postprocessor
+     */
+    async deactivatePostProcessor(postprocessorId) {
+        return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/deactivate`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deletes a postprocessor
+     */
+    async deletePostProcessor(postprocessorId) {
+        return this.httpDelete(`/developer/postprocessors/${this.agentId}/${postprocessorId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

package/dist/api/preprocessor.api.service.d.ts

@@ -0,0 +1,98 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/common.js";
+/**
+ * PreProcessor API Response Types
+ */
+export interface PreProcessorVersion {
+    version: string;
+    preprocessorId: string;
+    createdAt: string | number;
+    isActive?: boolean;
+}
+export interface GetPreProcessorsResponse {
+    preprocessors: Array<{
+        id: string;
+        name: string;
+        description?: string;
+        context?: string;
+        versions: PreProcessorVersion[];
+        activeVersionId?: string;
+    }>;
+}
+export interface CreatePreProcessorResponse {
+    id: string;
+    name: string;
+    description?: string;
+    agentId: string;
+    context?: string;
+}
+export interface PreProcessorVersionResponse {
+    versionId: string;
+    preprocessorId: string;
+    version: string;
+    createdAt: string;
+}
+export interface DeletePreProcessorResponse {
+    deleted: boolean;
+    deactivated?: boolean;
+    message: string;
+}
+/**
+ * PreProcessor API Service
+ * Handles all preprocessor-related API calls
+ */
+export default class PreProcessorApi extends HttpClient {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Retrieves all preprocessors for the agent
+     */
+    getPreProcessors(): Promise<ApiResponse<GetPreProcessorsResponse>>;
+    /**
+     * Creates a new preprocessor for the agent
+     */
+    createPreProcessor(data: {
+        name: string;
+        description?: string;
+        context?: string;
+    }): Promise<ApiResponse<CreatePreProcessorResponse>>;
+    /**
+     * Pushes a new version of a preprocessor
+     */
+    pushPreProcessor(preprocessorId: string, versionData: any): Promise<ApiResponse<PreProcessorVersionResponse>>;
+    /**
+     * Retrieves all versions of a specific preprocessor
+     */
+    getPreProcessorVersions(preprocessorId: string): Promise<ApiResponse<{
+        versions: PreProcessorVersion[];
+        activeVersionId?: string;
+    }>>;
+    /**
+     * Publishes a specific version of a preprocessor to production
+     */
+    publishPreProcessorVersion(preprocessorId: string, version: string): Promise<ApiResponse<{
+        message: string;
+        preprocessorId: string;
+        activeVersionId: string;
+        publishedAt: string;
+    }>>;
+    /**
+     * Activates a preprocessor
+     */
+    activatePreProcessor(preprocessorId: string): Promise<ApiResponse<{
+        message: string;
+        active: boolean;
+    }>>;
+    /**
+     * Deactivates a preprocessor
+     */
+    deactivatePreProcessor(preprocessorId: string): Promise<ApiResponse<{
+        message: string;
+        active: boolean;
+    }>>;
+    /**
+     * Deletes a preprocessor
+     */
+    deletePreProcessor(preprocessorId: string): Promise<ApiResponse<DeletePreProcessorResponse>>;
+}

package/dist/api/preprocessor.api.service.js

@@ -0,0 +1,76 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * PreProcessor API Service
+ * Handles all preprocessor-related API calls
+ */
+export default class PreProcessorApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Retrieves all preprocessors for the agent
+     */
+    async getPreProcessors() {
+        return this.httpGet(`/developer/preprocessors/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Creates a new preprocessor for the agent
+     */
+    async createPreProcessor(data) {
+        return this.httpPost(`/developer/preprocessors/${this.agentId}`, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Pushes a new version of a preprocessor
+     */
+    async pushPreProcessor(preprocessorId, versionData) {
+        return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/version`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Retrieves all versions of a specific preprocessor
+     */
+    async getPreProcessorVersions(preprocessorId) {
+        return this.httpGet(`/developer/preprocessors/${this.agentId}/${preprocessorId}/versions`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Publishes a specific version of a preprocessor to production
+     */
+    async publishPreProcessorVersion(preprocessorId, version) {
+        return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/${version}/publish`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Activates a preprocessor
+     */
+    async activatePreProcessor(preprocessorId) {
+        return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/activate`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deactivates a preprocessor
+     */
+    async deactivatePreProcessor(preprocessorId) {
+        return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/deactivate`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Deletes a preprocessor
+     */
+    async deletePreProcessor(preprocessorId) {
+        return this.httpDelete(`/developer/preprocessors/${this.agentId}/${preprocessorId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

package/dist/api/user.data.api.service.d.ts

@@ -1,6 +1,8 @@
 import { HttpClient } from "../common/http.client.js";
 import UserDataInstance from "../common/user.instance.js";
+import { Message } from "../interfaces/message.js";
 import { UserDataAPI } from "../types/index.js";
+import { ChatHistoryMessage } from "../interfaces/chat.js";
 export default class UserDataApi extends HttpClient implements UserDataAPI {
     private apiKey;
     private agentId;
@@ -30,4 +32,30 @@ export default class UserDataApi extends HttpClient implements UserDataAPI {
      * @throws Error if the clear operation fails or the request is unsuccessful
      */
     clear(): Promise<any>;
+    /**
+     * Sends a message to a specific user conversation for the agent
+     * @param userId - The unique identifier of the user to send the message to
+     * @param messages - An array of messages to send (can be text, image, or file types)
+     * @returns Promise resolving to the response data from the server
+     * @throws Error if the message sending fails or the request is unsuccessful
+     */
+    sendMessage(messages: Message[]): Promise<any>;
+    /**
+     * Gets the admin user for the specific agent
+     * @returns Promise resolving to the admin user data
+     * @throws Error if the admin user cannot be retrieved or the request is unsuccessful
+     */
+    getAdminUser(): Promise<any>;
+    /**
+     * Gets the chat history for the current user and agent
+     * @returns Promise resolving to an array of chat messages
+     * @throws Error if the chat history cannot be retrieved or the request is unsuccessful
+     *
+     * @example
+     * ```typescript
+     * const history = await User.getChatHistory();
+     * // Returns: [{ role: 'user', content: [...], createdAt: '...' }, ...]
+     * ```
+     */
+    getChatHistory(): Promise<ChatHistoryMessage[]>;
 }

package/dist/api/user.data.api.service.js

@@ -56,4 +56,55 @@ export default class UserDataApi extends HttpClient {
         }
         return {};
     }
+    /**
+     * Sends a message to a specific user conversation for the agent
+     * @param userId - The unique identifier of the user to send the message to
+     * @param messages - An array of messages to send (can be text, image, or file types)
+     * @returns Promise resolving to the response data from the server
+     * @throws Error if the message sending fails or the request is unsuccessful
+     */
+    async sendMessage(messages) {
+        const user = await this.getAdminUser();
+        const response = await this.httpPost(`/admin/agents/${this.agentId}/conversations/${user.uid}`, { messages }, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to send message');
+        }
+        return response.data;
+    }
+    /**
+     * Gets the admin user for the specific agent
+     * @returns Promise resolving to the admin user data
+     * @throws Error if the admin user cannot be retrieved or the request is unsuccessful
+     */
+    async getAdminUser() {
+        const response = await this.httpGet(`/admin`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to get admin user');
+        }
+        return response.data;
+    }
+    /**
+     * Gets the chat history for the current user and agent
+     * @returns Promise resolving to an array of chat messages
+     * @throws Error if the chat history cannot be retrieved or the request is unsuccessful
+     *
+     * @example
+     * ```typescript
+     * const history = await User.getChatHistory();
+     * // Returns: [{ role: 'user', content: [...], createdAt: '...' }, ...]
+     * ```
+     */
+    async getChatHistory() {
+        const response = await this.httpGet(`/chat/history/${this.agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (!response.success) {
+            throw new Error(response.error?.message || 'Failed to get chat history');
+        }
+        return response.data || [];
+    }
 }

package/dist/api/webhook.api.service.d.ts

@@ -0,0 +1,151 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/common.js";
+import { CreateWebhookDTO, PushWebhookVersionDTO, UpdateWebhookVersionDTO } from "../interfaces/webhooks.js";
+/**
+ * Webhook API Response Types
+ */
+export interface WebhookVersion {
+    version: string;
+    webhookId: string;
+    createdAt: string | number;
+    isActive?: boolean;
+}
+export interface GetWebhooksResponse {
+    webhooks: Array<{
+        id: string;
+        name: string;
+        description?: string;
+        context?: string;
+        versions: WebhookVersion[];
+        activeVersionId?: string;
+    }>;
+}
+export interface CreateWebhookResponse {
+    id: string;
+    name: string;
+    description?: string;
+    agentId: string;
+    context?: string;
+}
+export interface WebhookVersionResponse {
+    versionId: string;
+    webhookId: string;
+    version: string;
+    createdAt: string;
+}
+export interface UpdateWebhookVersionResponse {
+    versionId: string;
+    webhookId: string;
+    version: string;
+    updatedAt: string;
+}
+export interface DeleteWebhookResponse {
+    deleted: boolean;
+    deactivated?: boolean;
+    message: string;
+}
+/**
+ * Webhook API Service
+ * Handles all webhook-related API calls
+ */
+export default class WebhookApi extends HttpClient {
+    private apiKey;
+    private agentId;
+    /**
+     * 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: string, apiKey: string, agentId: string);
+    /**
+     * 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
+     */
+    getWebhooks(): Promise<ApiResponse<GetWebhooksResponse>>;
+    /**
+     * 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
+     */
+    createWebhook(webhookData: CreateWebhookDTO): Promise<ApiResponse<CreateWebhookResponse>>;
+    /**
+     * 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
+     */
+    pushWebhook(webhookId: string, versionData: PushWebhookVersionDTO): Promise<ApiResponse<WebhookVersionResponse>>;
+    /**
+     * 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
+     */
+    pushDevWebhook(webhookId: string, versionData: PushWebhookVersionDTO): Promise<ApiResponse<WebhookVersionResponse>>;
+    /**
+     * 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
+     */
+    updateDevWebhook(webhookId: string, sandboxVersionId: string, versionData: UpdateWebhookVersionDTO): Promise<ApiResponse<UpdateWebhookVersionResponse>>;
+    /**
+     * 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
+     */
+    getWebhookVersions(webhookId: string): Promise<ApiResponse<{
+        versions: WebhookVersion[];
+        activeVersionId?: string;
+    }>>;
+    /**
+     * 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
+     */
+    publishWebhookVersion(webhookId: string, version: string): Promise<ApiResponse<{
+        message: string;
+        webhookId: string;
+        activeVersionId: string;
+        publishedAt: string;
+    }>>;
+    /**
+     * 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
+     */
+    activateWebhook(webhookId: string): Promise<ApiResponse<{
+        message: string;
+        active: boolean;
+    }>>;
+    /**
+     * 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
+     */
+    deactivateWebhook(webhookId: string): Promise<ApiResponse<{
+        message: string;
+        active: boolean;
+    }>>;
+    /**
+     * 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
+     */
+    deleteWebhook(webhookId: string): Promise<ApiResponse<DeleteWebhookResponse>>;
+}