lua-cli 3.0.0-alpha.1 → 3.0.0-alpha.4

package/dist/types/skill.js

@@ -283,21 +283,6 @@ export class LuaJob {
     getMetadata() {
         return this.metadata;
     }
-    /**
-     * Executes the job.
-     * This is called by the scheduler at the appropriate time.
-     *
-     * @returns Promise resolving to job execution result
-     *
-     * @example
-     * ```typescript
-     * const result = await job.execute();
-     * console.log('Job completed:', result);
-     * ```
-     */
-    async execute() {
-        return this.executeFunction();
-    }
 }
 /**
  * Lua Webhook class.
@@ -330,19 +315,19 @@ export class LuaJob {
  *     email: z.string().email(),
  *     name: z.string()
  *   }),
- *   execute: async ({ query, headers, body }) => {
+ *   execute: async (query, headers, body) => {
  *     // Process the webhook...
  *     console.log('New user:', body.email);
  *     return { success: true, userId: body.userId };
  *   }
  * });
  *
- * // Execute the webhook with validated input
- * const result = await webhook.execute({
- *   query: { source: 'mobile' },
- *   headers: { 'x-api-key': 'secret-key' },
- *   body: { userId: '123', email: 'user@example.com', name: 'John' }
- * });
+ * // Execute the webhook with validated inputs
+ * const result = await webhook.execute(
+ *   { source: 'mobile' },
+ *   { 'x-api-key': 'secret-key' },
+ *   { userId: '123', email: 'user@example.com', name: 'John' }
+ * );
  * ```
  */
 export class LuaWebhook {
@@ -398,81 +383,82 @@ export class LuaWebhook {
      * Validates query parameters, headers, and body against their respective schemas
      * before executing the webhook function.
      *
-     * @param input - Input object containing query, headers, and/or body
-     * @param input.query - Query parameters object
-     * @param input.headers - Headers object
-     * @param input.body - Request body
+     * @param query - Query parameters object
+     * @param headers - Headers object
+     * @param body - Request body
      * @returns Promise resolving to webhook execution result
      * @throws Error if validation fails for any input
      *
      * @example
      * ```typescript
-     * const result = await webhook.execute({
-     *   query: { limit: '10' },
-     *   headers: { 'x-api-key': 'secret' },
-     *   body: { data: 'value' }
-     * });
+     * const result = await webhook.execute(
+     *   { limit: '10' },
+     *   { 'x-api-key': 'secret' },
+     *   { data: 'value' }
+     * );
      * ```
      */
-    async execute(input) {
-        const validatedInput = {};
+    async execute(query, headers, body) {
+        let validatedQuery = query;
+        let validatedHeaders = headers;
+        let validatedBody = body;
         // Validate query parameters if schema is provided
         if (this.querySchema) {
             try {
-                validatedInput.query = this.querySchema.parse(input.query || {});
+                validatedQuery = this.querySchema.parse(query || {});
             }
             catch (error) {
                 throw new Error(`Query parameter validation failed: ${error}`);
             }
         }
-        else {
-            validatedInput.query = input.query;
-        }
         // Validate headers if schema is provided
         if (this.headerSchema) {
             try {
-                validatedInput.headers = this.headerSchema.parse(input.headers || {});
+                validatedHeaders = this.headerSchema.parse(headers || {});
             }
             catch (error) {
                 throw new Error(`Header validation failed: ${error}`);
             }
         }
-        else {
-            validatedInput.headers = input.headers;
-        }
         // Validate body if schema is provided
         if (this.bodySchema) {
             try {
-                validatedInput.body = this.bodySchema.parse(input.body);
+                validatedBody = this.bodySchema.parse(body);
             }
             catch (error) {
                 throw new Error(`Body validation failed: ${error}`);
             }
         }
-        else {
-            validatedInput.body = input.body;
-        }
-        // Execute the webhook function with validated input
-        return this.executeFunction(validatedInput);
+        // Execute the webhook function with validated inputs as separate parameters
+        return this.executeFunction(validatedQuery, validatedHeaders, validatedBody);
     }
 }
 /**
  * PreProcessor class.
  * Processes user messages before they reach the agent.
+ * Can handle rich content (text, images, files).
  *
  * @example
  * ```typescript
- * const languageDetector = new PreProcessor({
- *   name: 'language-detector',
+ * const contentFilter = new PreProcessor({
+ *   name: 'content-filter',
  *   version: '1.0.0',
- *   description: 'Detects and translates messages',
- *   context: 'Detects language and translates to English if needed',
- *   execute: async (user, message, channel) => {
- *     const language = await detectLanguage(message);
- *     if (language !== 'en') {
- *       return await translate(message, 'en');
- *     }
- *     return message;
+ *   description: 'Filters and processes message content',
+ *   context: 'Filters spam, validates images, and adds context',
+ *   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;
+ *     });
  *   }
  * });
  * ```
@@ -483,6 +469,7 @@ export class 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.executeFunction = config.execute;
     }
     getName() {
@@ -497,8 +484,11 @@ export class PreProcessor {
     getContext() {
         return this.context;
     }
-    async execute(user, message, channel) {
-        return this.executeFunction(user, message, channel);
+    getAsync() {
+        return this.asyncMode;
+    }
+    async execute(user, messages, channel) {
+        return this.executeFunction(user, messages, channel);
     }
 }
 /**
@@ -524,6 +514,7 @@ export class 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() {
@@ -538,6 +529,9 @@ export class PostProcessor {
     getContext() {
         return this.context;
     }
+    getAsync() {
+        return this.asyncMode;
+    }
     async execute(user, message, response, channel) {
         return this.executeFunction(user, message, response, channel);
     }

package/dist/utils/bundling.d.ts

@@ -2,8 +2,15 @@
  * Bundling Utilities
  * Handles esbuild bundling of tools and main index
  */
+import { Plugin } from "esbuild";
 import { Project } from "ts-morph";
 import { ToolInfo } from '../interfaces/compile.js';
+/**
+ * esbuild plugin to inject sandbox globals instead of requiring lua-cli
+ * This removes require("lua-cli") statements and injects the global API objects
+ * that are available in the sandbox (Products, User, Data, Baskets, Orders, Webhooks, Jobs)
+ */
+export declare const sandboxGlobalsPlugin: Plugin;
 /**
  * Bundles a tool's TypeScript code into a standalone JavaScript file.
  * Uses esbuild to:
@@ -16,7 +23,7 @@ import { ToolInfo } from '../interfaces/compile.js';
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
  */
-export declare function bundleTool(tool: ToolInfo, distDir: string): Promise<void>;
+export declare function bundleTool(tool: ToolInfo, distDir: string, modifiedSource?: string): Promise<void>;
 /**
  * Bundles the main index.ts file into a standalone JavaScript file.
  * This creates the entry point for the skill.
@@ -57,10 +64,12 @@ export declare function bundlePostProcessor(postprocessor: any, indexFile: any,
  * Extracts execute code and input schema from a tool.
  * This function:
  * 1. Reads the bundled tool code
- * 2. Extracts the execute function
- * 3. Converts Zod schema to JSON Schema format
+ * 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
  */
-export declare function extractExecuteCode(tool: ToolInfo, project: Project): Promise<void>;
+export declare function extractExecuteCode(tool: ToolInfo, project: Project, distDir?: string): Promise<void>;

package/dist/utils/bundling.js

@@ -8,13 +8,34 @@ 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, } from '../config/compile.constants.js';
-import { wrapToolForVM, createExecuteFunction, evaluateZodSchemaToJsonSchema, } from './compile.js';
+import { wrapToolForVM, createExecuteFunction, 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.
+ */
+function stripLuaCliImports(sourceCode) {
+    return sourceCode
+        // Remove api-exports imports
+        .replace(/import\s+{([^}]+)}\s+from\s+["'][^"']*api-exports["'];?/g, '// api-exports imports removed - using sandbox globals')
+        // Remove lua-cli imports
+        .replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli["'];?/g, '// lua-cli imports removed - using sandbox globals')
+        // Remove lua-cli/skill imports (but keep LuaTool, etc. for type checking in temp files)
+        .replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli\/skill["'];?/g, (match, imports) => {
+        // Keep only LuaTool, LuaWebhook, LuaJob types for temp files
+        const typeImports = imports.split(',')
+            .map((imp) => imp.trim())
+            .filter((imp) => /^(LuaTool|LuaWebhook|LuaJob|LuaPreProcessor|LuaPostProcessor)$/.test(imp));
+        return typeImports.length > 0
+            ? `// lua-cli/skill imports removed - using sandbox globals (types kept for compilation)`
+            : '// lua-cli/skill imports removed - using sandbox globals';
+    });
+}
 /**
  * esbuild plugin to inject sandbox globals instead of requiring lua-cli
  * This removes require("lua-cli") statements and injects the global API objects
  * that are available in the sandbox (Products, User, Data, Baskets, Orders, Webhooks, Jobs)
  */
-const sandboxGlobalsPlugin = {
+export const sandboxGlobalsPlugin = {
     name: 'sandbox-globals',
     setup(build) {
         // Only process user files, not node_modules
@@ -24,12 +45,18 @@ const sandboxGlobalsPlugin = {
                 return null;
             }
             const contents = await fs.promises.readFile(args.path, 'utf8');
-            // Only transform files that import from lua-cli
-            if (!contents.includes('lua-cli')) {
+            // Only transform files that import from lua-cli or api-exports
+            if (!contents.includes('lua-cli') && !contents.includes('api-exports')) {
                 return null;
             }
             // Replace lua-cli imports with global references
             let transformedContents = contents;
+            // Replace named imports from api-exports (e.g., ../../../dist/api-exports)
+            // Match: import { Jobs, Products, etc. } from "../../../dist/api-exports"
+            transformedContents = transformedContents.replace(/import\s+{([^}]+)}\s+from\s+["'][^"']*api-exports["'];?/g, (match, imports) => {
+                // Just remove the import, globals will be available in sandbox
+                return '// api-exports imports removed - using sandbox globals';
+            });
             // Replace named imports from lua-cli
             // Match: import { Products, User, Data, etc. } from "lua-cli"
             transformedContents = transformedContents.replace(/import\s+{([^}]+)}\s+from\s+["']lua-cli["'];?/g, (match, imports) => {
@@ -83,12 +110,13 @@ const sandboxGlobalsPlugin = {
  * @param tool - The tool to bundle
  * @param distDir - The distribution directory for output
  */
-export async function bundleTool(tool, distDir) {
+export async function bundleTool(tool, distDir, modifiedSource) {
     writeProgress(`📦 Bundling ${tool.className}...`);
     try {
         const outputPath = path.join(distDir, COMPILE_DIRS.TOOLS, `${tool.className}.js`);
         let entryPoint = tool.filePath;
         let tempFile = null;
+        // Note: modifiedSource is handled via stdin below, no temp file needed
         // Check if tool is inline (in index.ts or src/index.ts)
         const isInlineInIndex = tool.filePath.endsWith('index.ts') || tool.filePath.endsWith('index.tsx');
         if (isInlineInIndex) {
@@ -121,12 +149,30 @@ export async function bundleTool(tool, distDir) {
                 entryPoint = tempFile;
             }
         }
-        await build({
-            ...ESBUILD_TOOL_CONFIG,
-            entryPoints: [entryPoint],
-            outfile: outputPath,
-            plugins: [sandboxGlobalsPlugin],
-        });
+        // Use stdin for modified source to preserve import resolution
+        if (modifiedSource && !isInlineInIndex) {
+            // Remove api-exports and lua-cli imports (they're available in sandbox)
+            const transformedSource = stripLuaCliImports(modifiedSource);
+            await build({
+                ...ESBUILD_TOOL_CONFIG,
+                stdin: {
+                    contents: transformedSource,
+                    resolveDir: path.dirname(tool.filePath),
+                    sourcefile: tool.filePath,
+                    loader: 'ts',
+                },
+                outfile: outputPath,
+                plugins: [sandboxGlobalsPlugin],
+            });
+        }
+        else {
+            await build({
+                ...ESBUILD_TOOL_CONFIG,
+                entryPoints: [entryPoint],
+                outfile: outputPath,
+                plugins: [sandboxGlobalsPlugin],
+            });
+        }
         // Wrap the bundled code for VM execution environment
         await wrapToolForVM(outputPath, tool);
         // Clean up temp file if created
@@ -303,10 +349,10 @@ async function bundleAndCompressWebhookCode(executeFunction, webhookName, distDi
     const tempOutput = path.join(tempDir, `${webhookName}-webhook.js`);
     try {
         // Write execute function as a module export
-        const moduleCode = `
+        const moduleCode = stripLuaCliImports(`
 // Webhook execute function for ${webhookName}
 export default ${executeFunction};
-`;
+`);
         fs.writeFileSync(tempFile, moduleCode);
         // Bundle with esbuild
         await build({
@@ -323,8 +369,7 @@ export default ${executeFunction};
         // Read bundled code
         let bundledCode = fs.readFileSync(tempOutput, 'utf8');
         // Wrap for webhook VM execution (similar to tools)
-        const wrappedCode = `(async (input) => {
-  const { query, headers, body } = input;
+        const wrappedCode = `(async (query, headers, body) => {
   
   // Execute the bundled webhook code
   ${bundledCode}
@@ -332,8 +377,8 @@ export default ${executeFunction};
   // Get the execute function from exports
   const executeFunction = module.exports.default || module.exports;
   
-  // Execute with proper input structure
-  return await executeFunction({ query, headers, body });
+  // Execute with three separate parameters (not an object)
+  return await executeFunction(query, headers, body);
 })`;
         // Compress the wrapped code
         const compressed = compressCode(wrappedCode);
@@ -472,10 +517,10 @@ async function bundleAndCompressJobCode(executeFunction, jobName, distDir) {
     const tempOutput = path.join(tempDir, `${jobName}-job.js`);
     try {
         // Write execute function as a module export
-        const moduleCode = `
+        const moduleCode = stripLuaCliImports(`
 // Job execute function for ${jobName}
 export default ${executeFunction};
-`;
+`);
         fs.writeFileSync(tempFile, moduleCode);
         // Bundle with esbuild
         await build({
@@ -597,7 +642,11 @@ export async function bundlePreProcessor(preprocessor, indexFile, distDir, proje
             compressedCode = await bundleAndCompressProcessorCode(executeFunction, preprocessor.name, 'pre', distDir);
         }
         return {
-            ...preprocessor,
+            name: preprocessor.name,
+            version: preprocessor.version,
+            description: preprocessor.description,
+            context: preprocessor.context,
+            async: preprocessor.async === true ? true : false, // Explicitly set boolean
             executeFunction,
             code: compressedCode
         };
@@ -675,7 +724,11 @@ export async function bundlePostProcessor(postprocessor, indexFile, distDir, pro
             compressedCode = await bundleAndCompressProcessorCode(executeFunction, postprocessor.name, 'post', distDir);
         }
         return {
-            ...postprocessor,
+            name: postprocessor.name,
+            version: postprocessor.version,
+            description: postprocessor.description,
+            context: postprocessor.context,
+            async: postprocessor.async === true ? true : false, // Explicitly set boolean
             executeFunction,
             code: compressedCode
         };
@@ -699,10 +752,10 @@ async function bundleAndCompressProcessorCode(executeFunction, processorName, ty
     try {
         // Processor execute functions receive: (user, message, [response], channel)
         const paramList = type === 'pre' ? 'user, message, channel' : 'user, message, response, channel';
-        const moduleCode = `
+        const moduleCode = stripLuaCliImports(`
 // ${type === 'pre' ? 'Pre' : 'Post'}Processor execute function for ${processorName}
 export default ${executeFunction};
-`;
+`);
         fs.writeFileSync(tempFile, moduleCode);
         await build({
             entryPoints: [tempFile],
@@ -751,13 +804,15 @@ export default ${executeFunction};
  * Extracts execute code and input schema from a tool.
  * This function:
  * 1. Reads the bundled tool code
- * 2. Extracts the execute function
- * 3. Converts Zod schema to JSON Schema format
+ * 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
  */
-export async function extractExecuteCode(tool, project) {
+export async function extractExecuteCode(tool, project, distDir) {
     try {
         const toolSourceFile = project.getSourceFile(tool.filePath);
         if (!toolSourceFile) {
@@ -793,6 +848,8 @@ export async function extractExecuteCode(tool, project) {
         }
         // 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
         // Extract and convert input schema
         tool.inputSchema = await extractInputSchema(classDecl, tool);
     }

package/dist/utils/compile.js

@@ -423,6 +423,7 @@ export function extractPreProcessorsMetadata(indexFile) {
                     let version = '';
                     let description = '';
                     let context = '';
+                    let asyncMode = false;
                     configObj.getProperties().forEach((prop) => {
                         if (Node.isPropertyAssignment(prop)) {
                             const propName = prop.getName();
@@ -439,6 +440,11 @@ export function extractPreProcessorsMetadata(indexFile) {
                             else if (propName === 'context' && value) {
                                 context = value.getText().replace(/['"]/g, '');
                             }
+                            else if (propName === 'async' && value) {
+                                // Properly extract boolean value by checking node kind
+                                const nodeKind = value.getKind();
+                                asyncMode = nodeKind === 110; // TrueKeyword = 110, FalseKeyword = 95
+                            }
                         }
                     });
                     if (name) {
@@ -446,7 +452,8 @@ export function extractPreProcessorsMetadata(indexFile) {
                             name,
                             version: version || '1.0.0',
                             description,
-                            context
+                            context,
+                            async: asyncMode
                         });
                     }
                 }
@@ -472,6 +479,7 @@ export function extractPostProcessorsMetadata(indexFile) {
                     let version = '';
                     let description = '';
                     let context = '';
+                    let asyncMode = false;
                     configObj.getProperties().forEach((prop) => {
                         if (Node.isPropertyAssignment(prop)) {
                             const propName = prop.getName();
@@ -488,6 +496,11 @@ export function extractPostProcessorsMetadata(indexFile) {
                             else if (propName === 'context' && value) {
                                 context = value.getText().replace(/['"]/g, '');
                             }
+                            else if (propName === 'async' && value) {
+                                // Properly extract boolean value by checking node kind
+                                const nodeKind = value.getKind();
+                                asyncMode = nodeKind === 110; // TrueKeyword = 110, FalseKeyword = 95
+                            }
                         }
                     });
                     if (name) {
@@ -495,7 +508,8 @@ export function extractPostProcessorsMetadata(indexFile) {
                             name,
                             version: version || '1.0.0',
                             description,
-                            context
+                            context,
+                            async: asyncMode
                         });
                     }
                 }
@@ -674,10 +688,12 @@ function extractValueFromNode(node) {
     if (Node.isNumericLiteral(node)) {
         return node.getLiteralValue();
     }
-    // Boolean literal
-    if (node.getKind() === 110 || node.getKind() === 95) { // TrueKeyword or FalseKeyword
-        return node.getText() === 'true';
-    }
+    // Boolean literal (TrueKeyword = 110, FalseKeyword = 95)
+    const nodeKind = node.getKind();
+    if (nodeKind === 110)
+        return true; // TrueKeyword
+    if (nodeKind === 95)
+        return false; // FalseKeyword
     // New expression (for tools: [new ToolClass()])
     // Extract just the class name for compatibility with buildSkillsArray
     if (Node.isNewExpression(node)) {
@@ -699,6 +715,11 @@ function extractValueFromNode(node) {
     // Template literal or other complex expressions
     // For persona, context, etc. that might be multiline
     const text = node.getText();
+    // Handle boolean strings (fallback if node kind check didn't catch it)
+    if (text === 'true')
+        return true;
+    if (text === 'false')
+        return false;
     // If it starts with a quote, remove quotes
     if ((text.startsWith('"') && text.endsWith('"')) ||
         (text.startsWith("'") && text.endsWith("'")) ||

package/dist/utils/dev-api.d.ts

@@ -4,7 +4,7 @@
  */
 import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../interfaces/dev.js';
 /**
- * Sends a chat message to the API with skill override for sandbox testing.
+ * Sends a chat message to the API with skill and processor overrides for sandbox testing.
  *
  * @param apiKey - User's API key
  * @param agentId - Agent ID
@@ -13,9 +13,10 @@ import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../
  * @param message - Message to send
  * @param persona - Optional persona override
  * @param deployData - Deploy data containing all skills
+ * @param config - Optional config for processor overrides
  * @returns The chat response text or null if failed
  */
-export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any): Promise<string | null>;
+export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any, config?: any): Promise<string | null>;
 /**
  * Updates an existing sandbox version.
  *
@@ -59,3 +60,42 @@ export declare function pushSingleSkillToSandbox(apiKey: string, agentId: string
  * @returns Map of skill names to their sandbox IDs
  */
 export declare function pushSkillsToSandbox(apiKey: string, agentId: string, deployData: any, isInitial?: boolean): Promise<SandboxIdsMap>;
+/**
+ * Pushes a single preprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param preprocessorId - PreProcessor ID
+ * @param preprocessorData - PreProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSinglePreProcessorToSandbox(apiKey: string, agentId: string, preprocessorId: string, preprocessorData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes a single postprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param postprocessorId - PostProcessor ID
+ * @param postprocessorData - PostProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSinglePostProcessorToSandbox(apiKey: string, agentId: string, postprocessorId: string, postprocessorData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes preprocessors and postprocessors to sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param config - Configuration with preprocessors and postprocessors
+ * @param bundledPreProcessors - Bundled preprocessor data from compilation
+ * @param bundledPostProcessors - Bundled postprocessor data from compilation
+ * @param isInitial - Whether this is the initial push
+ * @returns Object with counts of pushed processors
+ */
+export declare function pushProcessorsToSandbox(apiKey: string, agentId: string, config: any, bundledPreProcessors: any[], bundledPostProcessors: any[], isInitial?: boolean): Promise<{
+    preprocessors: number;
+    postprocessors: number;
+}>;