lua-cli 3.1.0-alpha.3 → 3.1.0-alpha.5

package/dist/types/skill.js

@@ -66,7 +66,6 @@ export const env = (key) => {
  *
  * const skill = new LuaSkill({
  *   name: 'weather-skill',
- *   version: '1.0.0',
  *   description: "Weather and calculator utilities",
  *   context: "This skill provides weather information and math operations. " +
  *            "Use get_weather for current conditions and calculator for arithmetic.",
@@ -83,7 +82,6 @@ export class LuaSkill {
      *
      * @param config - Configuration object containing skill metadata
      * @param config.name - Skill name (optional, defaults to 'unnamed-skill')
-     * @param config.version - Skill version (optional, defaults to '1.0.0')
      * @param config.description - Short description of what the skill does (1-2 sentences)
      * @param config.context - Detailed explanation of how the agent should use the tools
      * @param config.tools - Optional array of tools to add immediately
@@ -91,7 +89,6 @@ export class LuaSkill {
     constructor(config) {
         this.tools = [];
         this.name = config.name || 'unnamed-skill';
-        this.version = config.version || '1.0.0';
         this.description = config.description;
         this.context = config.context;
         // Add tools from constructor if provided
@@ -157,9 +154,7 @@ export class LuaSkill {
  * // Daily cleanup job at 2 AM
  * const dailyCleanup = new LuaJob({
  *   name: 'daily-cleanup',
- *   version: '1.0.0',
  *   description: "Daily database cleanup job",
- *   context: "Runs at 2 AM daily to clean up old records and optimize tables.",
  *   schedule: {
  *     type: 'cron',
  *     expression: '0 2 * * *',  // 2 AM every day
@@ -180,9 +175,7 @@ export class LuaSkill {
  * // One-time job
  * const sendWelcome = new LuaJob({
  *   name: 'send-welcome',
- *   version: '1.0.0',
  *   description: "Send welcome email to new users",
- *   context: "Scheduled one-time task to send welcome emails.",
  *   schedule: {
  *     type: 'once',
  *     executeAt: new Date('2025-12-31T10:00:00Z')
@@ -196,9 +189,7 @@ export class LuaSkill {
  * // Interval-based job (every 5 minutes)
  * const healthCheck = new LuaJob({
  *   name: 'health-check',
- *   version: '1.0.0',
  *   description: "System health check",
- *   context: "Runs every 5 minutes to check system health.",
  *   schedule: {
  *     type: 'interval',
  *     seconds: 300  // 5 minutes
@@ -215,9 +206,7 @@ export class LuaJob {
      *
      * @param config - Configuration object containing job metadata
      * @param config.name - Job name (optional, defaults to 'unnamed-job')
-     * @param config.version - Job version (optional, defaults to '1.0.0')
      * @param config.description - Short description of what the job does (1-2 sentences)
-     * @param config.context - Detailed explanation of the job's purpose
      * @param config.schedule - Schedule configuration (cron, once, or interval)
      * @param config.timeout - Optional timeout in seconds (default: 300)
      * @param config.retry - Optional retry configuration
@@ -226,9 +215,7 @@ export class LuaJob {
      */
     constructor(config) {
         this.name = config.name || 'unnamed-job';
-        this.version = config.version || '1.0.0';
         this.description = config.description;
-        this.context = config.context;
         this.schedule = config.schedule;
         this.timeout = config.timeout || 300;
         this.retry = config.retry;
@@ -241,24 +228,12 @@ export class LuaJob {
     getName() {
         return this.name;
     }
-    /**
-     * Gets the job version.
-     */
-    getVersion() {
-        return this.version;
-    }
     /**
      * Gets the job description.
      */
     getDescription() {
         return this.description;
     }
-    /**
-     * Gets the job context.
-     */
-    getContext() {
-        return this.context;
-    }
     /**
      * Gets the job schedule.
      */
@@ -299,10 +274,7 @@ export class LuaJob {
  *
  * const webhook = new LuaWebhook({
  *   name: 'user-created',
- *   version: '1.0.0',
  *   description: "Webhook that handles user creation events",
- *   context: "This webhook processes new user registration events. " +
- *            "It validates the user data and sends welcome emails.",
  *   querySchema: z.object({
  *     source: z.string().optional()
  *   }),
@@ -315,7 +287,8 @@ export class LuaJob {
  *     email: z.string().email(),
  *     name: z.string()
  *   }),
- *   execute: async (query, headers, body) => {
+ *   execute: async (event) => {
+ *     const { query, headers, body } = event;
  *     // Process the webhook...
  *     console.log('New user:', body.email);
  *     return { success: true, userId: body.userId };
@@ -336,9 +309,7 @@ export class LuaWebhook {
      *
      * @param config - Configuration object containing webhook metadata
      * @param config.name - Webhook name (optional, defaults to 'unnamed-webhook')
-     * @param config.version - Webhook version (optional, defaults to '1.0.0')
      * @param config.description - Short description of what the webhook does (1-2 sentences)
-     * @param config.context - Detailed explanation of the webhook's purpose and behavior
      * @param config.querySchema - Optional Zod schema for query parameter validation
      * @param config.headerSchema - Optional Zod schema for header validation
      * @param config.bodySchema - Optional Zod schema for body validation
@@ -346,9 +317,7 @@ export class LuaWebhook {
      */
     constructor(config) {
         this.name = config.name || 'unnamed-webhook';
-        this.version = config.version || '1.0.0';
         this.description = config.description;
-        this.context = config.context;
         this.querySchema = config.querySchema;
         this.headerSchema = config.headerSchema;
         this.bodySchema = config.bodySchema;
@@ -360,24 +329,12 @@ export class LuaWebhook {
     getName() {
         return this.name;
     }
-    /**
-     * Gets the webhook version.
-     */
-    getVersion() {
-        return this.version;
-    }
     /**
      * Gets the webhook description.
      */
     getDescription() {
         return this.description;
     }
-    /**
-     * Gets the webhook context.
-     */
-    getContext() {
-        return this.context;
-    }
     /**
      * Executes the webhook with validated input.
      * Validates query parameters, headers, and body against their respective schemas
@@ -429,8 +386,13 @@ export class LuaWebhook {
                 throw new Error(`Body validation failed: ${error}`);
             }
         }
-        // Execute the webhook function with validated inputs as separate parameters
-        return this.executeFunction(validatedQuery, validatedHeaders, validatedBody);
+        const event = {
+            query: validatedQuery || {},
+            headers: validatedHeaders || {},
+            body: validatedBody,
+            timestamp: new Date().toISOString(),
+        };
+        return this.executeFunction(event);
     }
 }
 /**
@@ -442,23 +404,23 @@ export class LuaWebhook {
  * ```typescript
  * const contentFilter = new PreProcessor({
  *   name: 'content-filter',
- *   version: '1.0.0',
  *   description: 'Filters and processes message content',
- *   context: 'Filters spam, validates images, and adds context',
+ *   priority: 10,
  *   execute: async (user, messages, channel) => {
- *     // Process each message
- *     return messages.map(msg => {
- *       if (msg.type === 'text') {
- *         // Filter spam from text
- *         const filtered = msg.text.replace(/spam/gi, '[filtered]');
- *         return { type: 'text', text: filtered };
- *       }
- *       if (msg.type === 'image') {
- *         // Could validate image, add watermark, etc.
- *         return msg;
- *       }
- *       return msg;
- *     });
+ *     // Check for spam
+ *     const hasSpam = messages.some(msg =>
+ *       msg.type === 'text' && msg.text.includes('spam')
+ *     );
+ *
+ *     if (hasSpam) {
+ *       return {
+ *         action: 'block',
+ *         response: "Message blocked due to spam content"
+ *       };
+ *     }
+ *
+ *     // Return messages to proceed
+ *     return { action: 'proceed' };
  *   }
  * });
  * ```
@@ -466,27 +428,23 @@ export class LuaWebhook {
 export class PreProcessor {
     constructor(config) {
         this.name = config.name || 'unnamed-preprocessor';
-        this.version = config.version || '1.0.0';
         this.description = config.description;
-        this.context = config.context;
         this.asyncMode = config.async ?? false; // Default to synchronous
+        this.priority = config.priority ?? 100;
         this.executeFunction = config.execute;
     }
     getName() {
         return this.name;
     }
-    getVersion() {
-        return this.version;
-    }
     getDescription() {
         return this.description;
     }
-    getContext() {
-        return this.context;
-    }
     getAsync() {
         return this.asyncMode;
     }
+    getPriority() {
+        return this.priority;
+    }
     async execute(user, messages, channel) {
         return this.executeFunction(user, messages, channel);
     }
@@ -499,11 +457,9 @@ export class PreProcessor {
  * ```typescript
  * const responseFormatter = new PostProcessor({
  *   name: 'response-formatter',
- *   version: '1.0.0',
  *   description: 'Formats responses with branding',
- *   context: 'Adds company signature to all responses',
  *   execute: async (user, message, response, channel) => {
- *     return response + '\n\n---\nPowered by Acme Corp';
+ *     return { modifiedResponse: response + '\n\n---\nPowered by Acme Corp' };
  *   }
  * });
  * ```
@@ -511,31 +467,108 @@ export class PreProcessor {
 export class PostProcessor {
     constructor(config) {
         this.name = config.name || 'unnamed-postprocessor';
-        this.version = config.version || '1.0.0';
         this.description = config.description;
-        this.context = config.context;
-        this.asyncMode = config.async ?? false; // Default to synchronous
         this.executeFunction = config.execute;
     }
     getName() {
         return this.name;
     }
-    getVersion() {
-        return this.version;
-    }
     getDescription() {
         return this.description;
     }
-    getContext() {
-        return this.context;
-    }
-    getAsync() {
-        return this.asyncMode;
-    }
     async execute(user, message, response, channel) {
         return this.executeFunction(user, message, response, channel);
     }
 }
+/**
+ * LuaMCPServer class.
+ * Defines an MCP (Model Context Protocol) server connection.
+ *
+ * MCP servers provide tools that can be used by your agent at runtime.
+ * You can connect to local servers (via stdio) or remote servers (via SSE/HTTP).
+ *
+ * @example
+ * ```typescript
+ * import { LuaMCPServer } from 'lua-cli';
+ *
+ * // Local MCP server via npx
+ * const wikipediaServer = new LuaMCPServer({
+ *   name: 'wikipedia',
+ *   transport: 'stdio',
+ *   command: 'npx',
+ *   args: ['-y', 'wikipedia-mcp'],
+ *   description: 'Wikipedia search and retrieval'
+ * });
+ *
+ * // Remote MCP server via SSE
+ * const weatherServer = new LuaMCPServer({
+ *   name: 'weather',
+ *   transport: 'sse',
+ *   url: 'https://api.example.com/mcp',
+ *   headers: {
+ *     'Authorization': 'Bearer ${env.WEATHER_API_KEY}'
+ *   },
+ *   description: 'Weather information service'
+ * });
+ * ```
+ */
+export class LuaMCPServer {
+    constructor(config) {
+        if (!config.name) {
+            throw new Error('MCP server name is required');
+        }
+        if (config.transport === 'stdio' && !config.command) {
+            throw new Error('Command is required for stdio transport');
+        }
+        if (config.transport === 'sse' && !config.url) {
+            throw new Error('URL is required for sse transport');
+        }
+        this.config = config;
+    }
+    getName() {
+        return this.config.name;
+    }
+    getTransport() {
+        return this.config.transport;
+    }
+    getTimeout() {
+        return this.config.timeout;
+    }
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Returns the server configuration in a format suitable for serialization.
+     * Environment variable references (${env.VAR_NAME}) are preserved for runtime resolution.
+     */
+    toJSON() {
+        const base = {
+            name: this.config.name,
+            transport: this.config.transport,
+        };
+        if (this.config.timeout) {
+            base.timeout = this.config.timeout;
+        }
+        if (this.config.transport === 'stdio') {
+            const stdioConfig = this.config;
+            base.command = stdioConfig.command;
+            if (stdioConfig.args) {
+                base.args = stdioConfig.args;
+            }
+            if (stdioConfig.env) {
+                base.env = stdioConfig.env;
+            }
+        }
+        else {
+            const sseConfig = this.config;
+            base.url = sseConfig.url;
+            if (sseConfig.headers) {
+                base.headers = sseConfig.headers;
+            }
+        }
+        return base;
+    }
+}
 /**
  * LuaAgent class.
  * Unified agent configuration that consolidates skills, webhooks, jobs, and processors.
@@ -556,7 +589,6 @@ export class PostProcessor {
  * export const agent = new LuaAgent({
  *   name: 'my-assistant',
  *   persona: 'You are a helpful AI assistant that can manage users and products.',
- *   welcomeMessage: 'Hello! How can I help you today?',
  *   skills: [userSkill],
  *   jobs: [healthCheckJob],
  *   webhooks: [webhookHandler],
@@ -572,22 +604,22 @@ export class LuaAgent {
      * @param config - Agent configuration
      * @param config.name - Agent name
      * @param config.persona - Agent persona (behavior and personality)
-     * @param config.welcomeMessage - Optional welcome message
      * @param config.skills - Optional array of skills
      * @param config.webhooks - Optional array of webhooks
      * @param config.jobs - Optional array of jobs
      * @param config.preProcessors - Optional array of preprocessors
      * @param config.postProcessors - Optional array of postprocessors
+     * @param config.mcpServers - Optional array of MCP servers
      */
     constructor(config) {
         this.name = config.name;
         this.persona = config.persona;
-        this.welcomeMessage = config.welcomeMessage;
         this.skills = config.skills || [];
         this.webhooks = config.webhooks || [];
         this.jobs = config.jobs || [];
         this.preProcessors = config.preProcessors || [];
         this.postProcessors = config.postProcessors || [];
+        this.mcpServers = config.mcpServers || [];
     }
     getName() {
         return this.name;
@@ -595,9 +627,6 @@ export class LuaAgent {
     getPersona() {
         return this.persona;
     }
-    getWelcomeMessage() {
-        return this.welcomeMessage;
-    }
     getSkills() {
         return this.skills;
     }
@@ -613,4 +642,7 @@ export class LuaAgent {
     getPostProcessors() {
         return this.postProcessors;
     }
+    getMCPServers() {
+        return this.mcpServers;
+    }
 }

package/dist/utils/agent-management.d.ts

@@ -1,9 +1,9 @@
 /**
  * Agent Management Utilities
- * Handles LuaAgent persona and welcome message synchronization with lua.skill.yaml
+ * Handles LuaAgent persona synchronization with lua.skill.yaml
  */
 /**
- * Syncs the agent's name, persona, and welcome message with lua.skill.yaml.
+ * Syncs the agent's name and persona with lua.skill.yaml.
  * This ensures the YAML configuration reflects the agent definition in code.
  *
  * @param agentMetadata - Agent metadata extracted from LuaAgent
@@ -11,15 +11,13 @@
 export declare function syncAgentPersonaWithYaml(agentMetadata: {
     name: string;
     persona: string;
-    welcomeMessage?: string;
 }): Promise<void>;
 /**
  * Reads the agent persona from lua.skill.yaml.
  * This can be used to ensure the code and YAML are in sync.
  *
- * @returns Agent persona and welcome message from YAML, or null if not found
+ * @returns Agent persona from YAML, or null if not found
  */
 export declare function readAgentPersonaFromYaml(): {
     persona?: string;
-    welcomeMessage?: string;
 } | null;

package/dist/utils/agent-management.js

@@ -1,13 +1,13 @@
 /**
  * Agent Management Utilities
- * Handles LuaAgent persona and welcome message synchronization with lua.skill.yaml
+ * Handles LuaAgent persona synchronization with lua.skill.yaml
  */
 import fs from "fs";
 import path from "path";
 import yaml from "js-yaml";
 import { COMPILE_FILES, YAML_FORMAT } from '../config/compile.constants.js';
 /**
- * Syncs the agent's name, persona, and welcome message with lua.skill.yaml.
+ * Syncs the agent's name and persona with lua.skill.yaml.
  * This ensures the YAML configuration reflects the agent definition in code.
  *
  * @param agentMetadata - Agent metadata extracted from LuaAgent
@@ -20,11 +20,10 @@ export async function syncAgentPersonaWithYaml(agentMetadata) {
         const yamlContent = fs.readFileSync(yamlPath, 'utf8');
         config = yaml.load(yamlContent);
     }
-    // Update agent section with name, persona, and welcome message
+    // Update agent section with persona
     config.agent = {
         ...config.agent,
-        persona: agentMetadata.persona,
-        welcomeMessage: agentMetadata.welcomeMessage
+        persona: agentMetadata.persona
     };
     // Store agent name as a comment or in metadata (YAML doesn't have an agentName field)
     // The agent name is primarily for the LuaAgent in code
@@ -45,7 +44,7 @@ export async function syncAgentPersonaWithYaml(agentMetadata) {
  * Reads the agent persona from lua.skill.yaml.
  * This can be used to ensure the code and YAML are in sync.
  *
- * @returns Agent persona and welcome message from YAML, or null if not found
+ * @returns Agent persona from YAML, or null if not found
  */
 export function readAgentPersonaFromYaml() {
     const yamlPath = path.join(process.cwd(), COMPILE_FILES.LUA_SKILL_YAML);
@@ -57,8 +56,7 @@ export function readAgentPersonaFromYaml() {
         const config = yaml.load(yamlContent);
         if (config.agent) {
             return {
-                persona: config.agent.persona,
-                welcomeMessage: config.agent.welcomeMessage
+                persona: config.agent.persona
             };
         }
     }

package/dist/utils/bundling.d.ts

@@ -65,15 +65,8 @@ export declare function bundlePreProcessor(preprocessor: any, indexFile: any, di
  */
 export declare function bundlePostProcessor(postprocessor: any, indexFile: any, distDir: string, project?: any, debugMode?: boolean): Promise<any>;
 /**
- * Extracts execute code and input schema from a tool.
- * This function:
- * 1. Reads the bundled tool code
- * 2. Detects and bundles any Jobs.create() calls within execute
- * 3. Extracts the execute function
- * 4. Converts Zod schema to JSON Schema format
- *
- * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
- * @param project - The ts-morph Project instance for AST analysis
- * @param distDir - Distribution directory for bundling nested jobs
+ * Extracts tool code from a bundled tool.
+ * Reads the bundled code, wraps it for VM execution (execute and condition),
+ * and converts the Zod schema to JSON Schema format.
  */
-export declare function extractExecuteCode(tool: ToolInfo, project: Project, distDir?: string): Promise<void>;
+export declare function extractToolCode(tool: ToolInfo, project: Project): Promise<void>;

package/dist/utils/bundling.js

@@ -8,7 +8,7 @@ import { build } from "esbuild";
 import { Project, Node } from "ts-morph";
 import { writeProgress } from "./cli.js";
 import { COMPILE_DIRS, COMPILE_FILES, ESBUILD_TOOL_CONFIG, ESBUILD_INDEX_CONFIG, DEFAULT_INPUT_SCHEMA, EXTERNAL_PACKAGES, } from '../config/compile.constants.js';
-import { wrapToolForVM, createExecuteFunction, evaluateZodSchemaToJsonSchema } from './compile.js';
+import { wrapExecuteForVM, wrapConditionForVM, evaluateZodSchemaToJsonSchema } from './compile.js';
 /**
  * Helper function to remove lua-cli and api-exports imports from source code.
  * Used when bundling via stdin or temp files where the plugin can't process them.
@@ -248,7 +248,8 @@ export const sandboxGlobalsPlugin = {
                 'Baskets': 'Baskets',
                 'Orders': 'Orders',
                 'Webhooks': 'Webhooks',
-                'Jobs': 'Jobs'
+                'Jobs': 'Jobs',
+                'Templates': 'Templates'
             };
             // Replace usage of imported names with globals
             for (const [importName, globalName] of Object.entries(globalMappings)) {
@@ -346,8 +347,6 @@ export async function bundleTool(tool, distDir, modifiedSource, debugMode) {
                 plugins: [sandboxGlobalsPlugin],
             });
         }
-        // Wrap the bundled code for VM execution environment
-        await wrapToolForVM(outputPath, tool);
         // Clean up temp file if created (unless in debug mode)
         if (tempFile && fs.existsSync(tempFile) && !debugMode) {
             try {
@@ -527,7 +526,7 @@ export async function bundleWebhook(webhook, indexFile, distDir, project, debugM
  * @returns Compressed base64-encoded bundled code
  */
 async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDir, sourceFilePath, debugMode) {
-    return bundleAndCompressExecuteFunction(executeFunction, webhookName, 'webhook', (bundledCode) => `(async (query, headers, body) => {
+    return bundleAndCompressExecuteFunction(executeFunction, webhookName, 'webhook', (bundledCode) => `(async (event) => {
   
   // Execute the bundled webhook code
   ${bundledCode}
@@ -535,8 +534,8 @@ async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDi
   // Get the execute function from exports
   const executeFunction = module.exports.default || module.exports;
   
-  // Execute with three separate parameters (not an object)
-  return await executeFunction(query, headers, body);
+  // Execute with the unified event object
+  return await executeFunction(event);
 })`, distDir, sourceFilePath, debugMode);
 }
 /**
@@ -733,7 +732,6 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
             name: preprocessor.name,
             version: preprocessor.version,
             description: preprocessor.description,
-            context: preprocessor.context,
             async: preprocessor.async === true ? true : false, // Explicitly set boolean
             executeFunction,
             code: compressedCode
@@ -819,8 +817,6 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
             name: postprocessor.name,
             version: postprocessor.version,
             description: postprocessor.description,
-            context: postprocessor.context,
-            async: postprocessor.async === true ? true : false, // Explicitly set boolean
             executeFunction,
             code: compressedCode
         };
@@ -846,18 +842,11 @@ async function bundleAndCompressProcessorCode(executeFunction, processorName, ty
 })`, distDir, sourceFilePath, debugMode);
 }
 /**
- * Extracts execute code and input schema from a tool.
- * This function:
- * 1. Reads the bundled tool code
- * 2. Detects and bundles any Jobs.create() calls within execute
- * 3. Extracts the execute function
- * 4. Converts Zod schema to JSON Schema format
- *
- * @param tool - The tool to extract metadata from (mutated with executeCode and inputSchema)
- * @param project - The ts-morph Project instance for AST analysis
- * @param distDir - Distribution directory for bundling nested jobs
+ * Extracts tool code from a bundled tool.
+ * Reads the bundled code, wraps it for VM execution (execute and condition),
+ * and converts the Zod schema to JSON Schema format.
  */
-export async function extractExecuteCode(tool, project, distDir) {
+export async function extractToolCode(tool, project) {
     try {
         const toolSourceFile = project.getSourceFile(tool.filePath);
         if (!toolSourceFile) {
@@ -891,28 +880,30 @@ export async function extractExecuteCode(tool, project, distDir) {
                 return;
             }
         }
-        // Extract execute code from bundled file
-        tool.executeCode = extractExecuteCodeFromBundledFile(tool);
-        // NOTE: Dynamic job bundling moved to source-level processing
-        // Attempting to extract from minified bundled code is too fragile
+        // Read bundled code and wrap for VM execution
+        const rawBundledCode = readBundledToolCode(tool);
+        if (rawBundledCode) {
+            tool.executeCode = wrapExecuteForVM(rawBundledCode, tool.className);
+            // Check if tool has condition and wrap it
+            const hasCondition = classDecl.getMethod('condition') || classDecl.getProperty('condition');
+            if (hasCondition) {
+                tool.conditionCode = wrapConditionForVM(rawBundledCode, tool.className);
+            }
+        }
         // Extract and convert input schema
         tool.inputSchema = await extractInputSchema(classDecl, tool);
     }
     catch (error) {
-        console.warn(`Warning: Could not extract execute code for ${tool.className}:`, error);
+        console.warn(`Warning: Could not extract tool metadata for ${tool.className}:`, error);
     }
 }
 /**
- * Extracts execute code from the bundled tool file.
- *
- * @param tool - The tool whose bundled code to read
- * @returns The execute function code or undefined if not found
+ * Reads the raw bundled tool code from the dist directory.
  */
-function extractExecuteCodeFromBundledFile(tool) {
+function readBundledToolCode(tool) {
     const bundledPath = path.join(process.cwd(), COMPILE_DIRS.DIST, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
     if (fs.existsSync(bundledPath)) {
-        const bundledCode = fs.readFileSync(bundledPath, 'utf8');
-        return createExecuteFunction(bundledCode, tool);
+        return fs.readFileSync(bundledPath, 'utf8');
     }
     return undefined;
 }