lua-cli 2.2.7 → 2.2.8-alpha.2

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

@@ -0,0 +1,18 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/admin";
+import { Organization } from "../interfaces/admin";
+import { AgentType } from "../interfaces/agent";
+import { CreateAgentRequest } from "../interfaces/agent";
+import { CreateAgentResponse } from "../interfaces/agent";
+import { Agent } from "../interfaces/agent";
+/**
+ * Agent API calls
+ */
+export default class AgentApi extends HttpClient {
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    getOrganizations(): Promise<ApiResponse<Organization[]>>;
+    getAgentTypes(): Promise<ApiResponse<AgentType[]>>;
+    createAgent(agentData: CreateAgentRequest): Promise<ApiResponse<CreateAgentResponse>>;
+    getAgent(agentId: string): Promise<ApiResponse<Agent>>;
+}

package/dist/api/agent.api.service.js

@@ -0,0 +1,30 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * Agent API calls
+ */
+export default class AgentApi extends HttpClient {
+    constructor(baseUrl, apiKey) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+    }
+    async getOrganizations() {
+        return this.httpGet(`/admin`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async getAgentTypes() {
+        return this.httpGet(`/agents/self-serve/types`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async createAgent(agentData) {
+        return this.httpPost(`/agents/self-serve/create`, agentData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async getAgent(agentId) {
+        return this.httpGet(`/admin/agents/${agentId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

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

@@ -0,0 +1,19 @@
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/admin";
+import { UserData } from "../interfaces/admin";
+/**
+ * Authentication API calls
+ */
+export default class AuthApi extends HttpClient {
+    constructor(baseUrl: string);
+    checkApiKey(apiKey: string): Promise<ApiResponse<UserData>>;
+    sendOtp(email: string): Promise<ApiResponse<{
+        message: string;
+    }>>;
+    verifyOtp(email: string, otp: string): Promise<ApiResponse<{
+        signInToken: string;
+    }>>;
+    getApiKey(signInToken: string): Promise<ApiResponse<{
+        apiKey: string;
+    }>>;
+}

package/dist/api/auth.api.service.js

@@ -0,0 +1,25 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * Authentication API calls
+ */
+export default class AuthApi extends HttpClient {
+    constructor(baseUrl) {
+        super(baseUrl);
+    }
+    async checkApiKey(apiKey) {
+        return this.httpGet(`/admin`, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    async sendOtp(email) {
+        return this.httpPost(`/otp`, { email, type: 'email' });
+    }
+    async verifyOtp(email, otp) {
+        return this.httpPost(`/otp/verify`, { email, pin: otp, type: 'email' });
+    }
+    async getApiKey(signInToken) {
+        return this.httpPost(`/profile/apiKey`, undefined, {
+            Authorization: `Bearer ${signInToken}`,
+        });
+    }
+}

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

@@ -0,0 +1,43 @@
+import BasketInstance from "../common/basket.instance.js";
+import { HttpClient } from "../common/http.client.js";
+import OrderInstance from "../common/order.instance.js";
+import { BasketStatus, CreateBasketRequest, AddItemToBasketRequest, Basket } from "../interfaces/baskets";
+import { UpdateBasketMetadataResponse } from "../interfaces/custom.data";
+import { BasketAPI } from "../types";
+export default class BasketApi extends HttpClient implements BasketAPI {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Create a new user basket
+     */
+    create(basketData: CreateBasketRequest): Promise<BasketInstance>;
+    /**
+     * Get all user baskets with optional status filter
+     */
+    get(status?: BasketStatus): Promise<BasketInstance[]>;
+    /**
+     * Add item to basket
+     */
+    addItem(basketId: string, itemData: AddItemToBasketRequest): Promise<Basket>;
+    /**
+     * Remove item from basket
+     */
+    removeItem(basketId: string, itemId: string): Promise<Basket>;
+    /**
+     * Clear basket (remove all items)
+     */
+    clear(basketId: string): Promise<Basket>;
+    /**
+     * Update basket status
+     */
+    updateStatus(basketId: string, status: BasketStatus): Promise<BasketStatus>;
+    /**
+     * Update basket metadata
+     */
+    updateMetadata(basketId: string, metadata: any): Promise<UpdateBasketMetadataResponse>;
+    /**
+     * Create order from basket
+     */
+    placeOrder(data: Record<string, any>, basketId: string): Promise<OrderInstance>;
+}

package/dist/api/basket.api.service.js

@@ -0,0 +1,115 @@
+import BasketInstance from "../common/basket.instance.js";
+import { HttpClient } from "../common/http.client.js";
+import OrderInstance from "../common/order.instance.js";
+import OrderApi from "./order.api.service";
+export default class BasketApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Create a new user basket
+     */
+    async create(basketData) {
+        const response = await this.httpPost(`/developer/agents/${this.agentId}/basket`, basketData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success && response.data) {
+            return new BasketInstance(this, response.data);
+        }
+        throw new Error(response.error?.message || 'Failed to create basket');
+    }
+    /**
+     * Get all user baskets with optional status filter
+     */
+    async get(status) {
+        const statusParam = status ? `?status=${status}` : '';
+        const response = await this.httpGet(`/developer/agents/${this.agentId}/basket/user${statusParam}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            const baskets = response.data;
+            return baskets.map((basket) => {
+                return new BasketInstance(this, basket);
+            });
+        }
+        throw new Error(response.error?.message || 'Failed to get user baskets');
+    }
+    /**
+     * Add item to basket
+     */
+    async addItem(basketId, itemData) {
+        const response = await this.httpPost(`/developer/agents/${this.agentId}/basket/${basketId}/item`, itemData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to add item to basket');
+    }
+    /**
+     * Remove item from basket
+     */
+    async removeItem(basketId, itemId) {
+        const response = await this.httpDelete(`/developer/agents/${this.agentId}/basket/${basketId}/item/${itemId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to remove item from basket');
+    }
+    /**
+     * Clear basket (remove all items)
+     */
+    async clear(basketId) {
+        const response = await this.httpDelete(`/developer/agents/${this.agentId}/basket/${basketId}/clear`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to clear basket');
+    }
+    /**
+     * Update basket status
+     */
+    async updateStatus(basketId, status) {
+        const response = await this.httpPut(`/developer/agents/${this.agentId}/basket/${basketId}/${status}`, undefined, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return status;
+        }
+        throw new Error(response.error?.message || 'Failed to update basket status');
+    }
+    /**
+     * Update basket metadata
+     */
+    async updateMetadata(basketId, metadata) {
+        console.log('updating user basket metadata', metadata);
+        const response = await this.httpPut(`/developer/agents/${this.agentId}/basket/${basketId}/metadata`, metadata, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return metadata;
+        }
+        throw new Error(response.error?.message || 'Failed to update basket metadata');
+    }
+    /**
+     * Create order from basket
+     */
+    async placeOrder(data, basketId) {
+        const response = await this.httpPost(`/developer/agents/${this.agentId}/order`, { basketId, data }, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success && response.data) {
+            //create order api instance
+            const orderApi = new OrderApi(this.baseUrl, this.apiKey, this.agentId);
+            const orderInstance = new OrderInstance(orderApi, response.data);
+            return orderInstance;
+        }
+        throw new Error(response.error?.message || 'Failed to create order');
+    }
+}

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

@@ -0,0 +1,9 @@
+import { ChatResponse } from "../interfaces/chat";
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/admin";
+import { ChatRequest } from "../interfaces/chat";
+export default class ChatApi extends HttpClient {
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    sendMessage(agentId: string, chatData: ChatRequest): Promise<ApiResponse<ChatResponse>>;
+}

package/dist/api/chat.api.service.js

@@ -0,0 +1,12 @@
+import { HttpClient } from "../common/http.client.js";
+export default class ChatApi extends HttpClient {
+    constructor(baseUrl, apiKey) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+    }
+    async sendMessage(agentId, chatData) {
+        return this.httpPost(`/chat/generate/${agentId}?channel=dev`, chatData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}

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

@@ -0,0 +1,33 @@
+import { HttpClient } from "../common/http.client.js";
+import { CustomDataAPI } from "../types";
+import { GetCustomDataResponse, UpdateCustomDataRequest, UpdateCustomDataResponse, DeleteCustomDataResponse } from "../interfaces/custom.data";
+import DataEntryInstance from "../common/data.entry.instance";
+export default class CustomDataApi extends HttpClient implements CustomDataAPI {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Create a new custom data entry
+     */
+    create(collectionName: string, data: Record<string, any>, searchText?: string): Promise<DataEntryInstance>;
+    /**
+     * Get custom data entries with optional filtering and pagination
+     */
+    get(collectionName: string, filter?: any, page?: number, limit?: number): Promise<GetCustomDataResponse>;
+    /**
+     * Get a single custom data entry by ID
+     */
+    getEntry(collectionName: string, entryId: string): Promise<DataEntryInstance>;
+    /**
+     * Update a custom data entry
+     */
+    update(collectionName: string, entryId: string, data: UpdateCustomDataRequest): Promise<UpdateCustomDataResponse>;
+    /**
+     * Search custom data entries by text
+     */
+    search(collectionName: string, searchText: string, limit?: number, scoreThreshold?: number): Promise<DataEntryInstance[]>;
+    /**
+     * Delete a custom data entry
+     */
+    delete(collectionName: string, entryId: string): Promise<DeleteCustomDataResponse>;
+}

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

@@ -0,0 +1,91 @@
+import { HttpClient } from "../common/http.client.js";
+import DataEntryInstance from "../common/data.entry.instance";
+// Custom Data API calls
+export default class CustomDataApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Create a new custom data entry
+     */
+    async create(collectionName, data, searchText) {
+        const response = await this.httpPost(`/developer/agents/${this.agentId}/custom-data/${collectionName}`, { data, searchText }, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        console.log('response', response);
+        if (response.success) {
+            return new DataEntryInstance(this, response.data, collectionName);
+        }
+        throw new Error(response.error?.message || 'Failed to create custom data entry');
+    }
+    /**
+     * Get custom data entries with optional filtering and pagination
+     */
+    async get(collectionName, filter, page = 1, limit = 10) {
+        let url = `/developer/agents/${this.agentId}/custom-data/${collectionName}?page=${page}&limit=${limit}`;
+        if (filter) {
+            const encodedFilter = encodeURIComponent(JSON.stringify(filter));
+            url += `&filter=${encodedFilter}`;
+        }
+        const response = await this.httpGet(url, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to get custom data entries');
+    }
+    /**
+     * Get a single custom data entry by ID
+     */
+    async getEntry(collectionName, entryId) {
+        const response = await this.httpGet(`/developer/agents/${this.agentId}/custom-data/${collectionName}/${entryId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return new DataEntryInstance(this, response.data, collectionName);
+        }
+        throw new Error(response.error?.message || 'Failed to get custom data entry');
+    }
+    /**
+     * Update a custom data entry
+     */
+    async update(collectionName, entryId, data) {
+        const response = await this.httpPut(`/developer/agents/${this.agentId}/custom-data/${collectionName}/${entryId}`, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to update custom data entry');
+    }
+    /**
+     * Search custom data entries by text
+     */
+    async search(collectionName, searchText, limit = 10, scoreThreshold = 0.6) {
+        const url = `/developer/agents/${this.agentId}/custom-data/${collectionName}/search?searchText=${encodeURIComponent(searchText)}&limit=${limit}&scoreThreshold=${scoreThreshold}`;
+        const response = await this.httpGet(url, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            const entries = response.data?.data || [];
+            return entries.map((entry) => new DataEntryInstance(this, entry, collectionName)) || [];
+        }
+        throw new Error(response.error?.message || 'Failed to search custom data entries');
+    }
+    /**
+     * Delete a custom data entry
+     */
+    async delete(collectionName, entryId) {
+        const response = await this.httpDelete(`/developer/agents/${this.agentId}/custom-data/${collectionName}/${entryId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        console.log('response', response);
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to delete custom data entry');
+    }
+}

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

@@ -0,0 +1,23 @@
+import { OrderAPI } from "../types";
+import { HttpClient } from "../common/http.client.js";
+import { CreateOrderRequest, OrderResponse } from "../interfaces/orders.js";
+import { OrderStatus } from "../interfaces/orders.js";
+import OrderInstance from "../common/order.instance.js";
+export default class OrderApi extends HttpClient implements OrderAPI {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Create order from basket
+     */
+    create(orderData: CreateOrderRequest): Promise<OrderInstance>;
+    /**
+     * Update order status
+     */
+    updateStatus(status: OrderStatus, orderId: string): Promise<OrderResponse>;
+    updateData(data: Record<string, any>, orderId: string): Promise<OrderResponse>;
+    /**
+     * Get user orders with optional status filter
+     */
+    get(status?: OrderStatus): Promise<OrderInstance[]>;
+}

package/dist/api/order.api.service.js

@@ -0,0 +1,57 @@
+import { HttpClient } from "../common/http.client.js";
+import OrderInstance from "../common/order.instance.js";
+export default class OrderApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Create order from basket
+     */
+    async create(orderData) {
+        const response = await this.httpPost(`/developer/agents/${this.agentId}/order`, orderData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success && response.data) {
+            const orderInstance = new OrderInstance(this, response.data);
+            return orderInstance;
+        }
+        throw new Error(response.error?.message || 'Failed to create order');
+    }
+    /**
+     * Update order status
+     */
+    async updateStatus(status, orderId) {
+        const response = await this.httpPut(`/developer/agents/${this.agentId}/order/${orderId}/${status}`, {}, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to update order status');
+    }
+    async updateData(data, orderId) {
+        const response = await this.httpPut(`/developer/agents/${this.agentId}/order/${orderId}`, data, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to update order status');
+    }
+    /**
+     * Get user orders with optional status filter
+     */
+    async get(status) {
+        const statusParam = status ? `?status=${status}` : '';
+        const response = await this.httpGet(`/developer/agents/${this.agentId}/order/user${statusParam}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            const orders = response.data;
+            return orders.map((order) => new OrderInstance(this, order)) || [];
+        }
+        throw new Error(response.error?.message || 'Failed to get user orders');
+    }
+}

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

@@ -0,0 +1,36 @@
+import { HttpClient } from "../common/http.client.js";
+import { ProductAPI } from "../types";
+import { Product } from "../interfaces/product";
+import { UpdateProductResponse } from "../interfaces/product";
+import { DeleteProductResponse } from "../interfaces/product";
+import ProductInstance from "../common/product.instance.js";
+import ProductPaginationInstance from "../common/product.pagination.instance.js";
+import ProductSearchInstance from "../common/product.search.instance.js";
+/**
+ * Product API calls
+ */
+export default class ProductApi extends HttpClient implements ProductAPI {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    /**
+     * Get all products for an agent with pagination
+     */
+    get(page?: number, limit?: number): Promise<ProductPaginationInstance>;
+    /**
+     * Create a new product
+     */
+    create(productData: Product): Promise<ProductInstance>;
+    /**
+     * Update an existing product
+     */
+    update(productData: Record<string, any>, productId: string): Promise<UpdateProductResponse>;
+    /**
+     * Delete a product
+     */
+    delete(productId: string): Promise<DeleteProductResponse>;
+    /**
+     * Search products by text query
+     */
+    search(searchQuery: string): Promise<ProductSearchInstance>;
+}

package/dist/api/products.api.service.js

@@ -0,0 +1,74 @@
+import { HttpClient } from "../common/http.client.js";
+import ProductInstance from "../common/product.instance.js";
+import ProductPaginationInstance from "../common/product.pagination.instance.js";
+import ProductSearchInstance from "../common/product.search.instance.js";
+/**
+ * Product API calls
+ */
+export default class ProductApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    /**
+     * Get all products for an agent with pagination
+     */
+    async get(page = 1, limit = 10) {
+        const response = await this.httpGet(`/developer/agents/${this.agentId}/products?page=${page}&limit=${limit}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return new ProductPaginationInstance(this, response);
+        }
+        throw new Error(response.error?.message || 'Failed to get products');
+    }
+    /**
+     * Create a new product
+     */
+    async create(productData) {
+        const response = await this.httpPost(`/developer/agents/${this.agentId}/products`, productData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success && response.data) {
+            return new ProductInstance(this, response.data.product);
+        }
+        throw new Error(response.error?.message || 'Failed to create product');
+    }
+    /**
+     * Update an existing product
+     */
+    async update(productData, productId) {
+        const response = await this.httpPut(`/developer/agents/${this.agentId}/products`, { ...productData, id: productId }, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to update product');
+    }
+    /**
+     * Delete a product
+     */
+    async delete(productId) {
+        const response = await this.httpDelete(`/developer/agents/${this.agentId}/products/${productId}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return response.data;
+        }
+        throw new Error(response.error?.message || 'Failed to delete product');
+    }
+    /**
+     * Search products by text query
+     */
+    async search(searchQuery) {
+        const response = await this.httpGet(`/developer/agents/${this.agentId}/products/search?searchQuery=${encodeURIComponent(searchQuery)}`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+        if (response.success) {
+            return new ProductSearchInstance(this, response);
+        }
+        throw new Error(response.error?.message || 'Failed to search products');
+    }
+}

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

@@ -0,0 +1,30 @@
+import { DevVersionResponse, UpdateDevVersionResponse } from "../interfaces/admin";
+import { HttpClient } from "../common/http.client.js";
+import { ApiResponse } from "../interfaces/admin";
+/**
+ * Skill API calls
+ */
+export default class SkillApi extends HttpClient {
+    private apiKey;
+    private agentId;
+    constructor(baseUrl: string, apiKey: string, agentId: string);
+    createSkill(skillData: any): Promise<ApiResponse<{
+        id: string;
+        name: string;
+        description?: string;
+        agentId: string;
+        context?: string;
+    }>>;
+    pushSkill(skillId: string, versionData: any): Promise<ApiResponse<DevVersionResponse>>;
+    pushDevSkill(skillId: string, versionData: any): Promise<ApiResponse<DevVersionResponse>>;
+    updateDevSkill(skillId: string, sandboxVersionId: string, versionData: any): Promise<ApiResponse<UpdateDevVersionResponse>>;
+    getSkillVersions(skillId: string): Promise<ApiResponse<{
+        versions: any[];
+    }>>;
+    publishSkillVersion(skillId: string, version: string): Promise<ApiResponse<{
+        message: string;
+        skillId: string;
+        activeVersionId: string;
+        publishedAt: string;
+    }>>;
+}

package/dist/api/skills.api.service.js

@@ -0,0 +1,42 @@
+import { HttpClient } from "../common/http.client.js";
+/**
+ * Skill API calls
+ */
+export default class SkillApi extends HttpClient {
+    constructor(baseUrl, apiKey, agentId) {
+        super(baseUrl);
+        this.apiKey = apiKey;
+        this.agentId = agentId;
+    }
+    async createSkill(skillData) {
+        // console.log(`Skill data:`, skillData);
+        return this.httpPost(`/developer/skills/${this.agentId}`, skillData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async pushSkill(skillId, versionData) {
+        return this.httpPost(`/developer/skills/${this.agentId}/${skillId}/version`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async pushDevSkill(skillId, versionData) {
+        return this.httpPost(`/developer/skills/${this.agentId}/${skillId}/version/sandbox`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async updateDevSkill(skillId, sandboxVersionId, versionData) {
+        return this.httpPut(`/developer/skills/${this.agentId}/${skillId}/version/sandbox/${sandboxVersionId}`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async getSkillVersions(skillId) {
+        return this.httpGet(`/developer/skills/${this.agentId}/${skillId}/versions`, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    async publishSkillVersion(skillId, version) {
+        return this.httpPut(`/developer/skills/${this.agentId}/${skillId}/${version}/publish`, undefined, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+}