lua-cli 3.0.3 → 3.1.0-alpha.1

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

@@ -83,7 +83,9 @@ export default class JobApi extends HttpClient {
      * @returns Promise resolving to an ApiResponse containing an array of jobs with their versions
      * @throws Error if the API request fails or the agent is not found
      */
-    getJobs(): Promise<ApiResponse<GetJobsResponse>>;
+    getJobs(options?: {
+        includeDynamic?: boolean;
+    }): Promise<ApiResponse<GetJobsResponse>>;
     /**
      * Retrieves a job by its unique identifier
      * @param jobId - The unique identifier of the job to retrieve

package/dist/api/job.api.service.js

@@ -22,8 +22,13 @@ export default class JobApi extends HttpClient {
      * @returns Promise resolving to an ApiResponse containing an array of jobs with their versions
      * @throws Error if the API request fails or the agent is not found
      */
-    async getJobs() {
-        return this.httpGet(`/developer/jobs/${this.agentId}`, {
+    async getJobs(options = {}) {
+        const queryParams = new URLSearchParams();
+        if (options.includeDynamic) {
+            queryParams.append('includeDynamic', 'true');
+        }
+        const url = `/developer/jobs/${this.agentId}?${queryParams.toString()}`;
+        return this.httpGet(url, {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }

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

@@ -15,21 +15,19 @@ export default class LogsApi extends HttpClient {
     constructor(baseUrl: string, apiKey: string);
     /**
      * Retrieves logs for an agent
-     * @param agentId - The unique identifier of the agent
+     * @param agentId - The ID of the agent
      * @param limit - Number of logs per page (default: 20)
      * @param page - Page number (default: 1)
+     * @param skillId - Optional skill ID to filter logs
+     * @param logType - Optional log type to filter logs
      * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
      */
-    getAgentLogs(agentId: string, limit?: number, page?: number): Promise<ApiResponse<LogsResponse>>;
-    /**
-     * Retrieves logs for a specific skill
-     * @param agentId - The unique identifier of the agent
-     * @param skillId - The unique identifier of the skill
-     * @param limit - Number of logs per page (default: 20)
-     * @param page - Page number (default: 1)
-     * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
-     */
-    getSkillLogs(agentId: string, skillId: string, limit?: number, page?: number): Promise<ApiResponse<LogsResponse>>;
+    getAgentLogs(agentId: string, limit: number, page: number, filters?: {
+        primitiveType?: "skill" | "job" | "webhook" | "preprocessor" | "postprocessor";
+        primitiveId?: string;
+        primitiveName?: string;
+        toolId?: string;
+        toolName?: string;
+        logType?: string;
+    }): Promise<ApiResponse<LogsResponse>>;
 }

package/dist/api/logs.api.service.js

@@ -15,28 +15,31 @@ export default class LogsApi extends HttpClient {
     }
     /**
      * Retrieves logs for an agent
-     * @param agentId - The unique identifier of the agent
+     * @param agentId - The ID of the agent
      * @param limit - Number of logs per page (default: 20)
      * @param page - Page number (default: 1)
+     * @param skillId - Optional skill ID to filter logs
+     * @param logType - Optional log type to filter logs
      * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
      */
-    async getAgentLogs(agentId, limit = 20, page = 1) {
-        return this.httpGet(`/developer/agents/${agentId}/logs?limit=${limit}&page=${page}`, {
-            Authorization: `Bearer ${this.apiKey}`,
+    async getAgentLogs(agentId, limit, page, filters = {}) {
+        const queryParams = new URLSearchParams({
+            limit: limit.toString(),
+            page: page.toString(),
         });
-    }
-    /**
-     * Retrieves logs for a specific skill
-     * @param agentId - The unique identifier of the agent
-     * @param skillId - The unique identifier of the skill
-     * @param limit - Number of logs per page (default: 20)
-     * @param page - Page number (default: 1)
-     * @returns Promise resolving to an ApiResponse containing logs and pagination
-     * @throws Error if the API request fails
-     */
-    async getSkillLogs(agentId, skillId, limit = 20, page = 1) {
-        return this.httpGet(`/developer/skills/${agentId}/${skillId}/logs?limit=${limit}&page=${page}`, {
+        if (filters.primitiveType)
+            queryParams.append("primitiveType", filters.primitiveType);
+        if (filters.primitiveId)
+            queryParams.append("primitiveId", filters.primitiveId);
+        if (filters.primitiveName)
+            queryParams.append("primitiveName", filters.primitiveName);
+        if (filters.toolId)
+            queryParams.append("toolId", filters.toolId);
+        if (filters.toolName)
+            queryParams.append("toolName", filters.toolName);
+        if (filters.logType)
+            queryParams.append("logType", filters.logType);
+        return this.httpGet(`/developer/agents/${agentId}/logs?${queryParams.toString()}`, {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }

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

@@ -29,7 +29,10 @@ export default class UserDataApi extends HttpClient {
         if (!response.success) {
             throw new Error(response.error?.message || 'Failed to get user data');
         }
-        return new UserDataInstance(this, response.data);
+        // Extract profile data and remove from response
+        const profile = response.data?._luaProfile;
+        const { _luaProfile, ...data } = response.data || {};
+        return new UserDataInstance(this, data, profile);
     }
     /**
      * Updates the current user's data for the specific agent
@@ -44,7 +47,9 @@ export default class UserDataApi extends HttpClient {
         if (!response.success) {
             throw new Error(response.error?.message || 'Failed to update user data');
         }
-        return response.data;
+        // Extract profile if present and remove from response
+        const { _luaProfile, ...cleanData } = response.data || {};
+        return cleanData;
     }
     /**
      * Clears all user data for the current user and specific agent

package/dist/commands/logs.js

@@ -9,6 +9,11 @@ import { readSkillConfig } from "../utils/files.js";
 import { withErrorHandling, writeSuccess, writeInfo, writeError, clearPromptLines } from "../utils/cli.js";
 import LogsApi from '../api/logs.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
+import SkillApi from "../api/skills.api.service.js";
+import JobApi from "../api/job.api.service.js";
+import WebhookApi from "../api/webhook.api.service.js";
+import PreprocessorApi from "../api/preprocessor.api.service.js";
+import PostprocessorApi from "../api/postprocessor.api.service.js";
 /**
  * Main logs command - displays agent/skill logs with navigation
  *
@@ -45,102 +50,147 @@ export async function logsCommand() {
                 message: "What logs do you want to view?",
                 choices: [
                     { name: "📋 All agent logs", value: "all" },
-                    { name: "🎯 Specific skill logs", value: "skill" }
-                ]
-            }
+                    { name: "🔎 Filter logs", value: "filter" },
+                ],
+            },
         ]);
         clearPromptLines(2);
         if (viewType === "all") {
             await viewAgentLogs(logsApi, agentId);
         }
         else {
-            await viewSkillLogs(logsApi, agentId, config);
+            await filterAndShowLogs(logsApi, agentId, apiKey);
         }
     }, "logs viewing");
 }
-/**
- * View all logs for an agent with pagination
- */
-async function viewAgentLogs(logsApi, agentId) {
-    let currentPage = 1;
-    const limit = 20;
-    let keepViewing = true;
-    while (keepViewing) {
-        const response = await logsApi.getAgentLogs(agentId, limit, currentPage);
-        if (!response.success) {
-            writeError(`❌ Error: ${response.error?.message || 'Unknown error'}`);
-            process.exit(1);
+async function filterAndShowLogs(logsApi, agentId, apiKey) {
+    const apiServices = {
+        skill: new SkillApi(BASE_URLS.API, apiKey, agentId),
+        job: new JobApi(BASE_URLS.API, apiKey, agentId),
+        webhook: new WebhookApi(BASE_URLS.API, apiKey, agentId),
+        preprocessor: new PreprocessorApi(BASE_URLS.API, apiKey, agentId),
+        postprocessor: new PostprocessorApi(BASE_URLS.API, apiKey, agentId),
+    };
+    let keepFiltering = true;
+    while (keepFiltering) {
+        const { filterType } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "filterType",
+                message: "Filter by:",
+                choices: [
+                    { name: "📋 All logs", value: "all" },
+                    new inquirer.Separator(),
+                    { name: "Skills", value: "skill" },
+                    { name: "Jobs", value: "job" },
+                    { name: "Webhooks", value: "webhook" },
+                    { name: "Preprocessors", value: "preprocessor" },
+                    { name: "Postprocessors", value: "postprocessor" },
+                    new inquirer.Separator(),
+                    { name: "← Back", value: "back" },
+                    new inquirer.Separator(),
+                ],
+            },
+        ]);
+        if (filterType === "all") {
+            await viewAgentLogs(logsApi, agentId);
+            return; // Exit to main command menu
         }
-        const data = response.data;
-        displayLogs(data.logs, data.pagination, "All Agent Logs");
-        // Navigation menu
-        const { action } = await inquirer.prompt([
+        if (filterType === "back") {
+            await logsCommand();
+            return; // Exit to main command menu
+        }
+        const primitiveType = filterType;
+        const capitalizedType = primitiveType.charAt(0).toUpperCase() + primitiveType.slice(1);
+        let response;
+        let items = [];
+        switch (primitiveType) {
+            case "skill":
+                response = await apiServices.skill.getSkills();
+                items = response.data?.skills || [];
+                break;
+            case "job":
+                response = await apiServices.job.getJobs({ includeDynamic: true });
+                items = response.data?.jobs || [];
+                break;
+            case "webhook":
+                response = await apiServices.webhook.getWebhooks();
+                items = response.data?.webhooks || [];
+                break;
+            case "preprocessor":
+                response = await apiServices.preprocessor.getPreProcessors();
+                items = response.data?.preprocessors || [];
+                break;
+            case "postprocessor":
+                response = await apiServices.postprocessor.getPostProcessors();
+                items = response.data?.postprocessors || [];
+                break;
+            default:
+                writeError("❌ Invalid filter type selected.");
+                continue;
+        }
+        if (!response || !response.success || !response.data) {
+            writeError(`❌ Could not fetch ${primitiveType}s from the API.`);
+            continue;
+        }
+        if (items.length === 0) {
+            writeInfo(`ℹ️ No ${primitiveType}s found for this agent.\n`);
+            continue;
+        }
+        const { selectedId } = await inquirer.prompt([
             {
                 type: "list",
-                name: "action",
-                message: "Navigation:",
-                choices: getNavigationChoices(data.pagination)
-            }
+                name: "selectedId",
+                message: `Select a ${primitiveType}:`,
+                choices: [
+                    { name: `All ${capitalizedType}s`, value: "all" },
+                    new inquirer.Separator(),
+                    ...items.map((item) => ({
+                        name: item.name,
+                        value: item.id,
+                    })),
+                    new inquirer.Separator(),
+                    { name: "← Back", value: "back" },
+                    new inquirer.Separator(),
+                ],
+            },
         ]);
-        clearPromptLines(2);
-        keepViewing = await handleNavigation(action, data.pagination, (page) => {
-            currentPage = page;
-        });
+        if (selectedId === "back") {
+            continue;
+        }
+        const filters = {
+            primitiveType,
+        };
+        if (selectedId !== "all") {
+            filters.primitiveId = selectedId;
+        }
+        await viewAgentLogs(logsApi, agentId, filters);
+        return;
     }
 }
 /**
- * View logs for a specific skill with pagination
+ * View all logs for an agent with pagination
  */
-async function viewSkillLogs(logsApi, agentId, config) {
-    // Get skills from config
-    const skills = config?.skills || [];
-    if (skills.length === 0) {
-        writeError("❌ No skills found in lua.skill.yaml");
-        writeInfo("💡 Run 'lua push' to deploy skills first.\n");
-        return;
-    }
-    // Let user select a skill
-    const skillChoices = skills.map((skill) => ({
-        name: `${skill.name} (${skill.skillId || 'No ID'})`,
-        value: skill.skillId
-    }));
-    skillChoices.push({
-        name: '← Back to main menu',
-        value: null
-    });
-    const { skillId } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "skillId",
-            message: "Select a skill:",
-            choices: skillChoices
-        }
-    ]);
-    if (!skillId) {
-        return;
-    }
-    clearPromptLines(2);
+async function viewAgentLogs(logsApi, agentId, filters = {}) {
     let currentPage = 1;
     const limit = 20;
     let keepViewing = true;
-    const selectedSkill = skills.find((s) => s.skillId === skillId);
-    const skillName = selectedSkill?.name || skillId;
     while (keepViewing) {
-        const response = await logsApi.getSkillLogs(agentId, skillId, limit, currentPage);
+        const response = await logsApi.getAgentLogs(agentId, limit, currentPage, filters);
         if (!response.success) {
             writeError(`❌ Error: ${response.error?.message || 'Unknown error'}`);
             process.exit(1);
         }
         const data = response.data;
-        displayLogs(data.logs, data.pagination, `Logs for ${skillName}`);
+        displayLogs(data.logs, data.pagination, "All Agent Logs");
         // Navigation menu
         const { action } = await inquirer.prompt([
             {
                 type: "list",
                 name: "action",
                 message: "Navigation:",
-                choices: getNavigationChoices(data.pagination)
-            }
+                choices: getNavigationChoices(data.pagination),
+            },
         ]);
         clearPromptLines(2);
         keepViewing = await handleNavigation(action, data.pagination, (page) => {
@@ -167,11 +217,21 @@ function displayLogs(logs, pagination, title) {
         const icon = getLogIcon(log.subType);
         const color = getLogColor(log.subType);
         console.log(color(`${icon} [${timestamp}] ${log.subType.toUpperCase()}`));
-        if (log.metadata.skillName) {
-            console.log(chalk.gray(`   Skill: ${log.metadata.skillName}`));
+        const { primitiveType, primitiveId, primitiveName, toolName, toolId } = log.metadata;
+        const capitalizedType = primitiveType
+            ? primitiveType.charAt(0).toUpperCase() + primitiveType.slice(1)
+            : "Item";
+        if (primitiveName) {
+            console.log(chalk.gray(`   ${capitalizedType} Name: ${primitiveName}`));
         }
-        if (log.metadata.toolId) {
-            console.log(chalk.gray(`   Tool: ${log.metadata.toolId}`));
+        if (primitiveId) {
+            console.log(chalk.gray(`   ${capitalizedType} ID:   ${primitiveId}`));
+        }
+        // Only show tool information for skills
+        if (primitiveType === "skill") {
+            if (toolName) {
+                console.log(chalk.gray(`   Tool Name: ${toolName}`));
+            }
         }
         if (log.duration !== undefined) {
             console.log(chalk.gray(`   Duration: ${log.duration}ms`));

package/dist/commands/persona.js

@@ -388,9 +388,11 @@ async function listPersonaVersions(context) {
                 choices: sortedVersions.map((version, index) => {
                     const date = new Date(version.createdDate);
                     const dateStr = date.toLocaleDateString();
-                    const deployedMark = version.isCurrent ? ' ⭐ CURRENT' : '';
+                    const timeStr = date.toLocaleTimeString();
+                    const status = version.status === 'draft' ? '[DRAFT]' : '';
+                    const currentMark = version.isCurrent ? ' ⭐ CURRENT' : '';
                     return {
-                        name: `Version ${version.version} (${dateStr})${deployedMark}`,
+                        name: `Version ${version.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
                         value: index
                     };
                 })
@@ -415,7 +417,9 @@ async function viewVersionDetails(versions) {
     console.log(`Persona Version ${version.version}`);
     console.log("=".repeat(60));
     console.log(`Created: ${date.toLocaleString()}`);
-    console.log(`Status: ${version.isCurrent ? '⭐ CURRENT' : 'Available'}`);
+    const versionStatus = version.status === 'draft' ? '🔨 DRAFT' : '';
+    console.log(`Version Status: ${versionStatus}`);
+    console.log(`Active Status: ${version.isCurrent ? '⭐ CURRENT' : 'Available'}`);
     if (version.createdBy) {
         console.log(`Created by: ${version.createdBy}`);
     }
@@ -480,8 +484,9 @@ async function deployPersonaVersion(context) {
                     const dateStr = date.toLocaleDateString();
                     const timeStr = date.toLocaleTimeString();
                     const currentMark = v.isCurrent ? ' ⭐ CURRENTLY DEPLOYED' : '';
+                    const status = v.status === "draft" ? "[DRAFT]" : "";
                     return {
-                        name: `Version ${v.version} - ${dateStr} ${timeStr}${currentMark}`,
+                        name: `Version ${v.version} ${status} - (${dateStr}) ${timeStr} ${currentMark}`,
                         value: v.version
                     };
                 })

package/dist/common/job.instance.js

@@ -2,7 +2,6 @@
  * Job Instance
  * Provides a convenient interface for interacting with a job
  */
-import UserDataInstance from './user.instance.js';
 import UserDataApi from '../api/user.data.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 /**
@@ -97,8 +96,7 @@ export class JobInstance {
         }
     }
     async user() {
-        const result = await this.userApi.get();
-        return new UserDataInstance(this.userApi, result);
+        return await this.userApi.get();
     }
     /**
      * Converts the job instance to JSON.

package/dist/common/user.instance.d.ts

@@ -1,21 +1,24 @@
 import { Message } from "../interfaces/message.js";
 import { UserDataAPI } from "../types/index.js";
+import { ImmutableUserProfile, UserAgentData } from "../interfaces/user.js";
 /**
  * User data instance class providing a fluent API for managing user data
  * Provides methods for updating and clearing data
  * Supports direct property access (e.g., user.name) instead of user.data.name
  */
 export default class UserDataInstance {
-    data: Record<string, any>;
+    data: UserAgentData;
     private userAPI;
+    _luaProfile: ImmutableUserProfile;
     [key: string]: any;
     /**
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
      * @param data - The user data from the API
+     * @param profile - The immutable user profile data
      * @returns Proxied instance that allows direct access to data properties
      */
-    constructor(api: UserDataAPI, data: any);
+    constructor(api: UserDataAPI, data: any, profile?: ImmutableUserProfile);
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized user data

package/dist/common/user.instance.js

@@ -8,17 +8,34 @@ export default class UserDataInstance {
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
      * @param data - The user data from the API
+     * @param profile - The immutable user profile data
      * @returns Proxied instance that allows direct access to data properties
      */
-    constructor(api, data) {
+    constructor(api, data, profile) {
         // Ensure data is always an object, never null or undefined
-        this.data = data && typeof data === 'object' ? data : {};
+        this.data = data && typeof data === "object" ? data : {};
         // Make userAPI non-enumerable so it doesn't show up in console.log
-        Object.defineProperty(this, 'userAPI', {
+        Object.defineProperty(this, "userAPI", {
             value: api,
             writable: true,
             enumerable: false,
-            configurable: true
+            configurable: true,
+        });
+        // Make _luaProfile non-enumerable and immutable
+        Object.defineProperty(this, "_luaProfile", {
+            get() {
+                return (profile || {
+                    userId: "",
+                    fullName: "",
+                    mobileNumbers: [],
+                    emailAddresses: [],
+                });
+            },
+            set(_) {
+                // silently ignore any attempts to modify
+            },
+            enumerable: false,
+            configurable: false,
         });
         // Return a proxy that allows direct property access
         return new Proxy(this, {
@@ -28,21 +45,31 @@ export default class UserDataInstance {
                     return Reflect.get(target, prop, receiver);
                 }
                 // Otherwise, try to get it from the data object (with null check)
-                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
+                if (typeof prop === "string" &&
+                    target.data &&
+                    typeof target.data === "object" &&
+                    prop in target.data) {
                     return target.data[prop];
                 }
                 return undefined;
             },
             set(target, prop, value, receiver) {
                 // Reserved properties that should be set on the instance itself
-                const reservedProps = ['data', 'userAPI', 'update', 'clear', 'toJSON'];
-                if (typeof prop === 'string' && reservedProps.includes(prop)) {
+                const reservedProps = [
+                    "data",
+                    "userAPI",
+                    "update",
+                    "clear",
+                    "toJSON",
+                    "_luaProfile",
+                ];
+                if (typeof prop === "string" && reservedProps.includes(prop)) {
                     return Reflect.set(target, prop, value, receiver);
                 }
                 // All other properties get set on the data object
-                if (typeof prop === 'string') {
+                if (typeof prop === "string") {
                     // Initialize data object if it doesn't exist
-                    if (!target.data || typeof target.data !== 'object') {
+                    if (!target.data || typeof target.data !== "object") {
                         target.data = {};
                     }
                     target.data[prop] = value;
@@ -55,7 +82,9 @@ export default class UserDataInstance {
                 if (prop in target) {
                     return true;
                 }
-                if (typeof prop === 'string' && target.data && typeof target.data === 'object') {
+                if (typeof prop === "string" &&
+                    target.data &&
+                    typeof target.data === "object") {
                     return prop in target.data;
                 }
                 return false;
@@ -63,7 +92,9 @@ export default class UserDataInstance {
             ownKeys(target) {
                 // Return both instance keys and data keys (with null check)
                 const instanceKeys = Reflect.ownKeys(target);
-                const dataKeys = target.data && typeof target.data === 'object' ? Object.keys(target.data) : [];
+                const dataKeys = target.data && typeof target.data === "object"
+                    ? Object.keys(target.data)
+                    : [];
                 return [...new Set([...instanceKeys, ...dataKeys])];
             },
             getOwnPropertyDescriptor(target, prop) {
@@ -73,16 +104,19 @@ export default class UserDataInstance {
                     return instanceDesc;
                 }
                 // Then check if it's a data property (with null check)
-                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
+                if (typeof prop === "string" &&
+                    target.data &&
+                    typeof target.data === "object" &&
+                    prop in target.data) {
                     return {
                         configurable: true,
                         enumerable: true,
                         writable: true,
-                        value: target.data[prop]
+                        value: target.data[prop],
                     };
                 }
                 return undefined;
-            }
+            },
         });
     }
     /**
@@ -96,7 +130,7 @@ export default class UserDataInstance {
      * Custom inspect method for Node.js console.log
      * @returns Formatted user data for console output
      */
-    [Symbol.for('nodejs.util.inspect.custom')]() {
+    [Symbol.for("nodejs.util.inspect.custom")]() {
         return this.data;
     }
     /**
@@ -112,7 +146,7 @@ export default class UserDataInstance {
             return this.data;
         }
         catch (error) {
-            throw new Error('Failed to update user data');
+            throw new Error("Failed to update user data");
         }
     }
     /**
@@ -126,7 +160,7 @@ export default class UserDataInstance {
             return true;
         }
         catch (error) {
-            throw new Error('Failed to clear user data');
+            throw new Error("Failed to clear user data");
         }
     }
     /**
@@ -140,7 +174,7 @@ export default class UserDataInstance {
             return true;
         }
         catch (error) {
-            throw new Error('Failed to save user data');
+            throw new Error("Failed to save user data");
         }
     }
     /**
@@ -155,7 +189,7 @@ export default class UserDataInstance {
             return true;
         }
         catch (error) {
-            throw new Error('Failed to send message');
+            throw new Error("Failed to send message");
         }
     }
     //get chat history
@@ -164,7 +198,7 @@ export default class UserDataInstance {
             return await this.userAPI.getChatHistory();
         }
         catch (error) {
-            throw new Error('Failed to get chat history');
+            throw new Error("Failed to get chat history");
         }
     }
 }

package/dist/interfaces/index.d.ts

@@ -4,7 +4,8 @@
  * This file serves as the main entry point for all interface definitions.
  * It re-exports interfaces and DTOs from various modules for convenient importing.
  */
-export { CreateWebhookDTO, PushWebhookVersionDTO, UpdateWebhookVersionDTO, WebhookVersion, Webhook, GetWebhooksResponse, DeleteWebhookResponse, CreateWebhookResponse, PushWebhookVersionResponse, } from './webhooks.js';
-export { CreateJobDTO, PushJobVersionDTO, UpdateJobVersionDTO, JobSchedule, JobScheduleType, JobRetryConfig, JobVersion, JobExecutionStatus, JobExecution, JobStatus, Job, GetJobsResponse, DeleteJobResponse, CreateJobResponse, PushJobVersionResponse, JobExecutionResponse, GetJobExecutionsResponse, } from './jobs.js';
-export { ApiResponse, Pagination, } from './common.js';
-export { SkillTool, SkillVersion, Skill, GetSkillsResponse, DeleteSkillResponse, } from './skills.js';
+export { CreateWebhookDTO, PushWebhookVersionDTO, UpdateWebhookVersionDTO, WebhookVersion, Webhook, GetWebhooksResponse, DeleteWebhookResponse, CreateWebhookResponse, PushWebhookVersionResponse, } from "./webhooks.js";
+export { CreateJobDTO, PushJobVersionDTO, UpdateJobVersionDTO, JobSchedule, JobScheduleType, JobRetryConfig, JobVersion, JobExecutionStatus, JobExecution, JobStatus, Job, GetJobsResponse, DeleteJobResponse, CreateJobResponse, PushJobVersionResponse, JobExecutionResponse, GetJobExecutionsResponse, } from "./jobs.js";
+export { ApiResponse, Pagination } from "./common.js";
+export { SkillTool, SkillVersion, Skill, GetSkillsResponse, DeleteSkillResponse, } from "./skills.js";
+export { ImmutableUserProfile, UserAgentData } from "./user.js";