lua-cli 2.3.0 → 2.4.0

package/dist/utils/dev-server.js

@@ -12,6 +12,11 @@ import { executeTool, createBroadcastConsole, loadEnvironmentVariables } from '.
 import { getSandboxSkillId } from './sandbox-storage.js';
 import { sendChatMessage } from './dev-api.js';
 import { CORS_HEADERS, HTTP_STATUS, DEV_DEFAULTS } from '../config/dev.constants.js';
+import { BASE_URLS } from '../config/constants.js';
+import ProductApi from '../api/products.api.service.js';
+import BasketApi from '../api/basket.api.service.js';
+import OrderApi from '../api/order.api.service.js';
+import CustomDataApi from '../api/custom.data.api.service.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
@@ -86,6 +91,26 @@ export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
             handleToolTestEndpoint(req, res, apiKey, agentId, wss);
             return;
         }
+        // Products routes
+        if (req.url?.startsWith('/api/products')) {
+            handleProductsEndpoint(req, res, apiKey, agentId);
+            return;
+        }
+        // Baskets routes
+        if (req.url?.startsWith('/api/baskets')) {
+            handleBasketsEndpoint(req, res, apiKey, agentId);
+            return;
+        }
+        // Orders routes
+        if (req.url?.startsWith('/api/orders')) {
+            handleOrdersEndpoint(req, res, apiKey, agentId);
+            return;
+        }
+        // Custom Data routes
+        if (req.url?.startsWith('/api/custom-data')) {
+            handleCustomDataEndpoint(req, res, apiKey, agentId);
+            return;
+        }
         if (req.method === 'GET' && req.url === '/') {
             handleIndexEndpoint(req, res, apiKey, agentId, skillId, sandboxId);
             return;
@@ -553,3 +578,233 @@ function handleStaticFile(req, res, filename, contentType) {
         res.end(`${filename} not found`);
     }
 }
+/**
+ * Handler for products API using ProductApi service
+ */
+async function handleProductsEndpoint(req, res, apiKey, agentId) {
+    const productApi = new ProductApi(BASE_URLS.API, apiKey, agentId);
+    try {
+        let result;
+        if (req.method === 'GET') {
+            if (req.url.includes('/search')) {
+                const searchQuery = new URL(req.url, 'http://localhost').searchParams.get('searchQuery') || '';
+                result = await productApi.search(searchQuery);
+            }
+            else if (req.url.match(/\/api\/products\/[^/]+$/)) {
+                const productId = req.url.split('/').pop();
+                result = await productApi.getById(productId);
+            }
+            else {
+                const url = new URL(req.url, 'http://localhost');
+                const page = parseInt(url.searchParams.get('page') || '1');
+                const limit = parseInt(url.searchParams.get('limit') || '20');
+                result = await productApi.get(page, limit);
+            }
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'POST') {
+            const body = await new Promise((resolve) => {
+                let data = '';
+                req.on('data', (chunk) => { data += chunk; });
+                req.on('end', () => resolve(data));
+            });
+            const productData = JSON.parse(body);
+            result = await productApi.create(productData);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: { product: result } }));
+        }
+        else if (req.method === 'PUT') {
+            const body = await new Promise((resolve) => {
+                let data = '';
+                req.on('data', (chunk) => { data += chunk; });
+                req.on('end', () => resolve(data));
+            });
+            const productData = JSON.parse(body);
+            result = await productApi.update(productData, productData.id);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'DELETE') {
+            const productId = req.url.split('/').pop();
+            result = await productApi.delete(productId);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
+    }
+}
+/**
+ * Handler for baskets API using BasketApi service
+ */
+async function handleBasketsEndpoint(req, res, apiKey, agentId) {
+    const basketApi = new BasketApi(BASE_URLS.API, apiKey, agentId);
+    try {
+        let result;
+        if (req.method === 'GET') {
+            if (req.url.match(/\/api\/baskets\/[^/]+$/)) {
+                const basketId = req.url.split('/').pop();
+                result = await basketApi.getById(basketId);
+            }
+            else {
+                const url = new URL(req.url, 'http://localhost');
+                const status = url.searchParams.get('status');
+                result = await basketApi.get(status);
+            }
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'POST') {
+            const body = await new Promise((resolve) => {
+                let data = '';
+                req.on('data', (chunk) => { data += chunk; });
+                req.on('end', () => resolve(data));
+            });
+            const basketData = JSON.parse(body);
+            result = await basketApi.create(basketData);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'DELETE') {
+            const basketId = req.url.split('/').pop();
+            // Baskets don't have a direct delete in the API, use clear instead
+            result = await basketApi.clear(basketId);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
+    }
+}
+/**
+ * Handler for orders API using OrderApi service
+ */
+async function handleOrdersEndpoint(req, res, apiKey, agentId) {
+    const orderApi = new OrderApi(BASE_URLS.API, apiKey, agentId);
+    try {
+        let result;
+        if (req.method === 'GET') {
+            if (req.url.match(/\/api\/orders\/[^/]+$/)) {
+                const orderId = req.url.split('/').pop();
+                result = await orderApi.getById(orderId);
+            }
+            else {
+                const url = new URL(req.url, 'http://localhost');
+                const status = url.searchParams.get('status');
+                result = await orderApi.get(status);
+            }
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'POST') {
+            const body = await new Promise((resolve) => {
+                let data = '';
+                req.on('data', (chunk) => { data += chunk; });
+                req.on('end', () => resolve(data));
+            });
+            const orderData = JSON.parse(body);
+            result = await orderApi.create(orderData);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'PUT') {
+            if (req.url.includes('/status')) {
+                const orderId = req.url.split('/')[3];
+                const body = await new Promise((resolve) => {
+                    let data = '';
+                    req.on('data', (chunk) => { data += chunk; });
+                    req.on('end', () => resolve(data));
+                });
+                const { status } = JSON.parse(body);
+                result = await orderApi.updateStatus(status, orderId);
+            }
+            else {
+                const body = await new Promise((resolve) => {
+                    let data = '';
+                    req.on('data', (chunk) => { data += chunk; });
+                    req.on('end', () => resolve(data));
+                });
+                const orderData = JSON.parse(body);
+                const orderId = req.url.split('/').pop();
+                result = await orderApi.updateData(orderData, orderId);
+            }
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
+    }
+}
+/**
+ * Handler for custom data API using CustomDataApi service
+ */
+async function handleCustomDataEndpoint(req, res, apiKey, agentId) {
+    const customDataApi = new CustomDataApi(BASE_URLS.API, apiKey, agentId);
+    try {
+        let result;
+        const pathParts = req.url.split('/');
+        const collectionName = pathParts[3]; // /api/custom-data/{collection}
+        if (req.method === 'GET') {
+            if (req.url.includes('/search')) {
+                const url = new URL(req.url, 'http://localhost');
+                const searchText = url.searchParams.get('searchText') || '';
+                const limit = parseInt(url.searchParams.get('limit') || '10');
+                const scoreThreshold = parseFloat(url.searchParams.get('scoreThreshold') || '0.7');
+                result = await customDataApi.search(collectionName, searchText, limit, scoreThreshold);
+            }
+            else if (pathParts.length > 4) {
+                const entryId = pathParts[4];
+                result = await customDataApi.getEntry(collectionName, entryId);
+            }
+            else {
+                const url = new URL(req.url, 'http://localhost');
+                const filter = url.searchParams.get('filter') ? JSON.parse(url.searchParams.get('filter')) : undefined;
+                const page = parseInt(url.searchParams.get('page') || '1');
+                const limit = parseInt(url.searchParams.get('limit') || '10');
+                result = await customDataApi.get(collectionName, filter, page, limit);
+            }
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'POST') {
+            const body = await new Promise((resolve) => {
+                let data = '';
+                req.on('data', (chunk) => { data += chunk; });
+                req.on('end', () => resolve(data));
+            });
+            const { data, searchText } = JSON.parse(body);
+            result = await customDataApi.create(collectionName, data, searchText);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'PUT') {
+            const entryId = pathParts[4];
+            const body = await new Promise((resolve) => {
+                let data = '';
+                req.on('data', (chunk) => { data += chunk; });
+                req.on('end', () => resolve(data));
+            });
+            const updateData = JSON.parse(body);
+            result = await customDataApi.update(collectionName, entryId, updateData);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+        else if (req.method === 'DELETE') {
+            const entryId = pathParts[4];
+            result = await customDataApi.delete(collectionName, entryId);
+            res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, data: result }));
+        }
+    }
+    catch (error) {
+        res.writeHead(HTTP_STATUS.SERVER_ERROR, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: error.message || 'API error' }));
+    }
+}

package/dist/utils/init-agent.js

@@ -80,9 +80,9 @@ export async function createNewAgent(apiKey, agentType, businessConfig, metadata
     // Wait for agent to be ready
     await waitForAgentReady();
     // Validate required fields from API response
-    const agentId = createAgentResult.data?.data?.agentId;
-    const agentName = createAgentResult.data?.data?.name;
-    const orgId = createAgentResult.data?.data?.org?.id;
+    const agentId = createAgentResult.data?.agentId;
+    const agentName = createAgentResult.data?.name;
+    const orgId = createAgentResult.data?.org?.id;
     if (!agentId || !agentName || !orgId) {
         throw new Error("Failed to create agent: Missing required fields in API response");
     }

package/dist/utils/prompt-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Prompt Handler Utility
+ * Gracefully handles user interruptions (Ctrl+C) in inquirer prompts
+ */
+/**
+ * Wraps inquirer.prompt to gracefully handle Ctrl+C interruptions
+ */
+export declare function safePrompt<T = any>(questions: any): Promise<T | null>;
+/**
+ * Setup global SIGINT handler for graceful exits
+ */
+export declare function setupGlobalInterruptHandler(): void;

package/dist/utils/prompt-handler.js

@@ -0,0 +1,31 @@
+/**
+ * Prompt Handler Utility
+ * Gracefully handles user interruptions (Ctrl+C) in inquirer prompts
+ */
+import inquirer from 'inquirer';
+/**
+ * Wraps inquirer.prompt to gracefully handle Ctrl+C interruptions
+ */
+export async function safePrompt(questions) {
+    try {
+        const answers = await inquirer.prompt(questions);
+        return answers;
+    }
+    catch (error) {
+        // Handle Ctrl+C gracefully
+        if (error.name === 'ExitPromptError' || error.message?.includes('SIGINT')) {
+            console.log('\n\n👋 Operation cancelled. Goodbye!\n');
+            process.exit(0);
+        }
+        throw error;
+    }
+}
+/**
+ * Setup global SIGINT handler for graceful exits
+ */
+export function setupGlobalInterruptHandler() {
+    process.on('SIGINT', () => {
+        console.log('\n\n👋 Operation cancelled. Goodbye!\n');
+        process.exit(0);
+    });
+}

package/dist/utils/push-helpers.d.ts

@@ -2,6 +2,28 @@
  * Push Helper Utilities
  * Helper functions for the push command
  */
+/**
+ * Selected skill for pushing.
+ */
+export interface SelectedSkill {
+    name: string;
+    version: string;
+    skillId: string;
+}
+/**
+ * Prompts user to select a skill from available skills.
+ *
+ * @param skills - Array of available skills
+ * @returns Selected skill
+ */
+export declare function promptSkillSelection(skills: SelectedSkill[]): Promise<SelectedSkill>;
+/**
+ * Prompts user to confirm or update the version.
+ *
+ * @param currentVersion - Current version of the skill
+ * @returns Confirmed or updated version
+ */
+export declare function promptVersionConfirmOrUpdate(currentVersion: string): Promise<string>;
 /**
  * Reads the version from skill configuration.
  *
@@ -29,10 +51,32 @@ export declare function confirmVersionPush(version: string): Promise<boolean>;
  */
 export declare function validatePushConfig(config: any): void;
 /**
- * Validates that deploy data matches configuration.
+ * Gets available skills from configuration.
+ *
+ * @param config - Skill configuration
+ * @returns Array of available skills
+ */
+export declare function getAvailableSkills(config: any): SelectedSkill[];
+/**
+ * Updates a skill's version in the YAML configuration file.
+ *
+ * @param skillName - Name of the skill to update
+ * @param newVersion - New version to set
+ */
+export declare function updateSkillVersionInYaml(skillName: string, newVersion: string): void;
+/**
+ * Validates that deploy data matches configuration for a specific skill.
  *
  * @param deployData - Deploy data from deploy.json
- * @param configVersion - Version from configuration
+ * @param selectedSkill - The selected skill to validate
  * @throws Error if deploy data is invalid or version mismatch
  */
-export declare function validateDeployData(deployData: any, configVersion: string): void;
+export declare function validateDeployData(deployData: any, selectedSkill: SelectedSkill): void;
+/**
+ * Extracts the deploy data for a specific skill from the deploy.json.
+ *
+ * @param deployData - Deploy data from deploy.json
+ * @param skillName - Name of the skill to extract
+ * @returns The deploy data for the specific skill
+ */
+export declare function getSkillDeployData(deployData: any, skillName: string): any;

package/dist/utils/push-helpers.js

@@ -7,6 +7,77 @@ import path from 'path';
 import inquirer from 'inquirer';
 import { readSkillConfig } from './files.js';
 import { clearPromptLines } from './cli.js';
+/**
+ * Prompts user to select a skill from available skills.
+ *
+ * @param skills - Array of available skills
+ * @returns Selected skill
+ */
+export async function promptSkillSelection(skills) {
+    const skillChoices = skills.map((skill) => ({
+        name: `${skill.name} (v${skill.version})`,
+        value: skill
+    }));
+    const { selectedSkill } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "selectedSkill",
+            message: "Select a skill to push:",
+            choices: skillChoices
+        }
+    ]);
+    clearPromptLines(2);
+    return selectedSkill;
+}
+/**
+ * Prompts user to confirm or update the version.
+ *
+ * @param currentVersion - Current version of the skill
+ * @returns Confirmed or updated version
+ */
+export async function promptVersionConfirmOrUpdate(currentVersion) {
+    console.log(`\nCurrent version: ${currentVersion}`);
+    const { newVersion } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "newVersion",
+            message: "Enter new version to push:",
+            default: incrementPatchVersion(currentVersion),
+            validate: (input) => {
+                if (!input || input.trim() === "") {
+                    return "Version cannot be empty";
+                }
+                // Basic semver validation
+                const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+                if (!semverRegex.test(input.trim())) {
+                    return "Version must follow semver format (e.g., 1.0.0, 1.0.0-alpha.1)";
+                }
+                return true;
+            }
+        }
+    ]);
+    clearPromptLines(2);
+    return newVersion.trim();
+}
+/**
+ * Increments the patch version automatically (e.g., 1.0.0 → 1.0.1)
+ *
+ * @param version - Current version string
+ * @returns Incremented version
+ */
+function incrementPatchVersion(version) {
+    const semverRegex = /^(\d+)\.(\d+)\.(\d+)(-[a-zA-Z0-9.-]+)?$/;
+    const match = version.match(semverRegex);
+    if (match) {
+        const major = match[1];
+        const minor = match[2];
+        const patch = parseInt(match[3]) + 1;
+        const prerelease = match[4] || '';
+        return `${major}.${minor}.${patch}${prerelease}`;
+    }
+    // If doesn't match semver, return as-is
+    return version;
+}
 /**
  * Reads the version from skill configuration.
  *
@@ -57,28 +128,114 @@ export function validatePushConfig(config) {
     if (!config) {
         throw new Error("No lua.skill.yaml found. Please run this command from a skill directory.");
     }
-    if (!config.skill?.version) {
-        throw new Error("No version found in skill configuration");
-    }
     if (!config.agent?.agentId) {
         throw new Error("Missing agentId in skill configuration");
     }
-    if (!config.skill?.skillId) {
-        throw new Error("Missing skillId in skill configuration");
+    // Check for new multi-skill format
+    if (config.skills && Array.isArray(config.skills) && config.skills.length > 0) {
+        return; // Valid multi-skill config
+    }
+    // Check for legacy single-skill format
+    if (config.skill?.version && config.skill?.skillId) {
+        return; // Valid legacy config
     }
+    throw new Error("No skills found in configuration. Please compile your skill first.");
 }
 /**
- * Validates that deploy data matches configuration.
+ * Gets available skills from configuration.
+ *
+ * @param config - Skill configuration
+ * @returns Array of available skills
+ */
+export function getAvailableSkills(config) {
+    // Check for new multi-skill format
+    if (config.skills && Array.isArray(config.skills) && config.skills.length > 0) {
+        return config.skills.map((skill) => ({
+            name: skill.name,
+            version: skill.version,
+            skillId: skill.skillId
+        }));
+    }
+    // Fallback to legacy single-skill format
+    if (config.skill) {
+        return [{
+                name: config.skill.name || 'unnamed-skill',
+                version: config.skill.version,
+                skillId: config.skill.skillId
+            }];
+    }
+    return [];
+}
+/**
+ * Updates a skill's version in the YAML configuration file.
+ *
+ * @param skillName - Name of the skill to update
+ * @param newVersion - New version to set
+ */
+export function updateSkillVersionInYaml(skillName, newVersion) {
+    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
+    if (!fs.existsSync(yamlPath)) {
+        throw new Error("lua.skill.yaml not found");
+    }
+    const yamlContent = fs.readFileSync(yamlPath, 'utf8');
+    // Simple regex-based replacement to preserve formatting
+    // Match the skill entry and update its version
+    const skillPattern = new RegExp(`(- name: ${skillName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s+version: )[^\\n]+`, 'g');
+    const updatedContent = yamlContent.replace(skillPattern, `$1${newVersion}`);
+    if (updatedContent === yamlContent) {
+        // Try legacy format
+        const legacyPattern = /(\s+version: )[^\n]+/;
+        const legacyUpdated = yamlContent.replace(legacyPattern, `$1${newVersion}`);
+        fs.writeFileSync(yamlPath, legacyUpdated, 'utf8');
+    }
+    else {
+        fs.writeFileSync(yamlPath, updatedContent, 'utf8');
+    }
+}
+/**
+ * Validates that deploy data matches configuration for a specific skill.
  *
  * @param deployData - Deploy data from deploy.json
- * @param configVersion - Version from configuration
+ * @param selectedSkill - The selected skill to validate
  * @throws Error if deploy data is invalid or version mismatch
  */
-export function validateDeployData(deployData, configVersion) {
+export function validateDeployData(deployData, selectedSkill) {
     if (!deployData) {
         throw new Error("No deploy.json found. Compilation may have failed.");
     }
-    if (deployData.version !== configVersion) {
-        throw new Error(`Version mismatch: config has ${configVersion}, deploy.json has ${deployData.version}`);
+    // Handle multi-skill format
+    if (deployData.skills && Array.isArray(deployData.skills)) {
+        const skillData = deployData.skills.find((s) => s.name === selectedSkill.name);
+        if (!skillData) {
+            throw new Error(`Skill "${selectedSkill.name}" not found in deploy.json. Compilation may have failed.`);
+        }
+        if (skillData.version !== selectedSkill.version) {
+            throw new Error(`Version mismatch for "${selectedSkill.name}": ` +
+                `config has ${selectedSkill.version}, deploy.json has ${skillData.version || 'undefined'}`);
+        }
+        return;
+    }
+    // Handle legacy single-skill format
+    if (deployData.version !== selectedSkill.version) {
+        throw new Error(`Version mismatch: config has ${selectedSkill.version}, deploy.json has ${deployData.version || 'undefined'}`);
+    }
+}
+/**
+ * Extracts the deploy data for a specific skill from the deploy.json.
+ *
+ * @param deployData - Deploy data from deploy.json
+ * @param skillName - Name of the skill to extract
+ * @returns The deploy data for the specific skill
+ */
+export function getSkillDeployData(deployData, skillName) {
+    // Handle multi-skill format
+    if (deployData.skills && Array.isArray(deployData.skills)) {
+        const skillData = deployData.skills.find((s) => s.name === skillName);
+        if (!skillData) {
+            throw new Error(`Skill "${skillName}" not found in deploy.json`);
+        }
+        return skillData;
     }
+    // Handle legacy single-skill format
+    return deployData;
 }

package/dist/utils/sandbox.js

@@ -131,6 +131,19 @@ export function createSandbox(options) {
     // };
     // Create console object (use custom console if provided, otherwise default)
     const consoleObj = customConsole || console;
+    // Create API service instances
+    const userService = new UserDataApiService(BASE_URLS.API, apiKey, agentId);
+    const productService = new ProductApiService(BASE_URLS.API, apiKey, agentId);
+    const dataService = new CustomDataApiService(BASE_URLS.API, apiKey, agentId);
+    const basketsService = new BasketApiService(BASE_URLS.API, apiKey, agentId);
+    const orderService = new OrderApiService(BASE_URLS.API, apiKey, agentId);
+    // Override User service methods if needed
+    // Example: Override the update method
+    // const originalUpdate = userService.update.bind(userService);
+    // userService.update = async (data: any) => {
+    //   console.log('Custom update logic here');
+    //   return await originalUpdate(data);
+    // };
     // Create comprehensive polyfills for browser/Node.js APIs
     const polyfills = {
         // AbortController polyfill
@@ -257,11 +270,11 @@ export function createSandbox(options) {
         null: null,
         Infinity: Infinity,
         NaN: NaN,
-        User: new UserDataApiService(BASE_URLS.API, apiKey, agentId),
-        Product: new ProductApiService(BASE_URLS.API, apiKey, agentId),
-        CustomData: new CustomDataApiService(BASE_URLS.API, apiKey, agentId),
-        Basket: new BasketApiService(BASE_URLS.API, apiKey, agentId),
-        Order: new OrderApiService(BASE_URLS.API, apiKey, agentId),
+        User: userService,
+        Products: productService,
+        Data: dataService,
+        Baskets: basketsService,
+        Orders: orderService,
         // Environment variables function
         env: (key) => envVars[key]
     };