lua-cli 2.3.0 → 2.3.2

package/dist/utils/deployment.js

@@ -62,9 +62,11 @@ export async function createLegacyDeploymentData(tools, luaDir, indexFile) {
     const skillsArray = buildSkillsArray(skillsMetadata, skillToTools, tools);
     // Ensure all skills exist in YAML config and have valid IDs
     const updatedSkillsArray = await ensureSkillsExistInYaml(skillsArray, config);
+    // Override versions from YAML config if they exist
+    const finalSkillsArray = overrideVersionsFromConfig(updatedSkillsArray, config);
     // Write deployment data
     const deployData = {
-        skills: updatedSkillsArray
+        skills: finalSkillsArray
     };
     fs.writeFileSync(path.join(luaDir, COMPILE_FILES.DEPLOY_JSON), JSON.stringify(deployData, null, JSON_FORMAT.INDENT));
     // Write individual tool files (uncompressed for debugging)
@@ -144,6 +146,36 @@ function buildSkillsArray(skillsMetadata, skillToTools, tools) {
         };
     });
 }
+/**
+ * Overrides skill versions from YAML config.
+ * This ensures that any version updates in the YAML take precedence over code versions.
+ *
+ * @param skillsArray - Array of skills from code
+ * @param config - Skill configuration from YAML
+ * @returns Skills array with versions overridden from config
+ */
+function overrideVersionsFromConfig(skillsArray, config) {
+    // Get version map from YAML config
+    const configVersionMap = new Map();
+    if (config.skills && Array.isArray(config.skills)) {
+        config.skills.forEach((skill) => {
+            if (skill.name && skill.version) {
+                configVersionMap.set(skill.name, skill.version);
+            }
+        });
+    }
+    // Override versions in skills array
+    return skillsArray.map(skill => {
+        const configVersion = configVersionMap.get(skill.name);
+        if (configVersion) {
+            return {
+                ...skill,
+                version: configVersion
+            };
+        }
+        return skill;
+    });
+}
 /**
  * Writes individual tool files to the .lua directory for debugging.
  * These are uncompressed versions of the tool code.

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/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,72 @@ 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) {
+    const { versionAction } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "versionAction",
+            message: `Current version is ${currentVersion}. What would you like to do?`,
+            choices: [
+                { name: `Keep current version (${currentVersion})`, value: "keep" },
+                { name: "Update version", value: "update" }
+            ]
+        }
+    ]);
+    clearPromptLines(2);
+    if (versionAction === "update") {
+        const { newVersion } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "newVersion",
+                message: "Enter new version:",
+                default: 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();
+    }
+    return currentVersion;
+}
 /**
  * Reads the version from skill configuration.
  *
@@ -57,28 +123,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,
+        Product: productService,
+        Data: dataService,
+        Baskets: basketsService,
+        Order: orderService,
         // Environment variables function
         env: (key) => envVars[key]
     };