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

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

@@ -69,8 +69,8 @@ export interface JobExecutionResponse {
  * Handles all job-related API calls
  */
 export default class JobApi extends HttpClient {
-    private apiKey;
-    private agentId;
+    apiKey: string;
+    agentId: string;
     /**
      * Creates an instance of JobApi
      * @param baseUrl - The base URL for the API
@@ -92,19 +92,28 @@ export default class JobApi extends HttpClient {
      */
     getJob(jobId: string): Promise<JobInstance>;
     /**
-     * Creates a new job for the agent
-     * @param jobData - The job data including name, description, and optional context
+     * Creates a new job for the agent.
+     * Optionally creates initial version and activates the job in one call.
+     *
+     * @param jobData - The job data including name, description, schedule, and optional version
+     * @param jobData.version - If provided, creates first version automatically
+     * @param jobData.activate - If true, activates the job immediately
      * @returns Promise resolving to an ApiResponse containing the created job details
      * @throws Error if the job creation fails or validation errors occur
      */
     createJob(jobData: CreateJobDTO): Promise<ApiResponse<CreateJobResponse>>;
     /**
-    * Creates a new job for the agent
-    * @param jobData - The job data including name, description, and optional context
-    * @returns Promise resolving to an JobInstance containing the created job details
+    * Creates a new job for the agent and returns a JobInstance.
+    * Supports automatic version creation and activation.
+    *
+    * @param jobData - The job data including name, description, schedule, and optional version
+    * @param jobData.version - If provided, creates first version automatically
+    * @param jobData.activate - If true, activates the job immediately
+    * @returns Promise resolving to a JobInstance containing the created job details
     * @throws Error if the job creation fails or validation errors occur
     */
     createJobInstance(jobData: CreateJobDTO): Promise<JobInstance>;
+    private compressCode;
     /**
      * Pushes a new version of a job to production
      * @param jobId - The unique identifier of the job

package/dist/api/job.api.service.js

@@ -1,5 +1,6 @@
 import { HttpClient } from "../common/http.client.js";
 import { JobInstance } from "../common/job.instance.js";
+import { gzipSync } from "zlib";
 /**
  * Job API Service
  * Handles all job-related API calls
@@ -42,8 +43,12 @@ export default class JobApi extends HttpClient {
         throw new Error(response.error?.message || 'Failed to get job');
     }
     /**
-     * Creates a new job for the agent
-     * @param jobData - The job data including name, description, and optional context
+     * Creates a new job for the agent.
+     * Optionally creates initial version and activates the job in one call.
+     *
+     * @param jobData - The job data including name, description, schedule, and optional version
+     * @param jobData.version - If provided, creates first version automatically
+     * @param jobData.activate - If true, activates the job immediately
      * @returns Promise resolving to an ApiResponse containing the created job details
      * @throws Error if the job creation fails or validation errors occur
      */
@@ -53,12 +58,19 @@ export default class JobApi extends HttpClient {
         });
     }
     /**
-    * Creates a new job for the agent
-    * @param jobData - The job data including name, description, and optional context
-    * @returns Promise resolving to an JobInstance containing the created job details
+    * Creates a new job for the agent and returns a JobInstance.
+    * Supports automatic version creation and activation.
+    *
+    * @param jobData - The job data including name, description, schedule, and optional version
+    * @param jobData.version - If provided, creates first version automatically
+    * @param jobData.activate - If true, activates the job immediately
+    * @returns Promise resolving to a JobInstance containing the created job details
     * @throws Error if the job creation fails or validation errors occur
     */
     async createJobInstance(jobData) {
+        if (jobData.version?.executeFunction && jobData.version?.executeFunction.length > 0) {
+            jobData.version.code = this.compressCode(jobData.version.executeFunction);
+        }
         const response = await this.httpPost(`/developer/jobs/${this.agentId}`, jobData, {
             Authorization: `Bearer ${this.apiKey}`,
         });
@@ -67,6 +79,10 @@ export default class JobApi extends HttpClient {
         }
         throw new Error(response.error?.message || 'Failed to create job');
     }
+    compressCode(code) {
+        const compressed = gzipSync(code);
+        return compressed.toString('base64');
+    }
     /**
      * Pushes a new version of a job to production
      * @param jobId - The unique identifier of the job

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

@@ -59,8 +59,26 @@ export default class PostProcessorApi extends HttpClient {
     }): Promise<ApiResponse<CreatePostProcessorResponse>>;
     /**
      * Pushes a new version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Postprocessor description
+     * @param versionData.context - Postprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
-    pushPostProcessor(postprocessorId: string, versionData: any): Promise<ApiResponse<PostProcessorVersionResponse>>;
+    pushPostProcessor(postprocessorId: string, versionData: {
+        name: string;
+        version: string;
+        description?: string;
+        context?: string;
+        postprocessorId: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<PostProcessorVersionResponse>>;
     /**
      * Retrieves all versions of a specific postprocessor
      */
@@ -95,4 +113,46 @@ export default class PostProcessorApi extends HttpClient {
      * Deletes a postprocessor
      */
     deletePostProcessor(postprocessorId: string): Promise<ApiResponse<DeletePostProcessorResponse>>;
+    /**
+     * Pushes a new sandbox (dev) version of a postprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    pushDevPostProcessor(postprocessorId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        versionId: string;
+        postprocessorId: string;
+        version: string;
+        createdAt: string;
+    }>>;
+    /**
+     * Updates an existing sandbox version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    updateDevPostProcessor(postprocessorId: string, sandboxVersionId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        message: string;
+        versionId: string;
+    }>>;
 }

package/dist/api/postprocessor.api.service.js

@@ -27,6 +27,15 @@ export default class PostProcessorApi extends HttpClient {
     }
     /**
      * Pushes a new version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Postprocessor description
+     * @param versionData.context - Postprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
     async pushPostProcessor(postprocessorId, versionData) {
         return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/version`, versionData, {
@@ -73,4 +82,30 @@ export default class PostProcessorApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Pushes a new sandbox (dev) version of a postprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    async pushDevPostProcessor(postprocessorId, versionData) {
+        return this.httpPost(`/developer/postprocessors/${this.agentId}/${postprocessorId}/version/sandbox`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates an existing sandbox version of a postprocessor
+     *
+     * @param postprocessorId - The postprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    async updateDevPostProcessor(postprocessorId, sandboxVersionId, versionData) {
+        return this.httpPut(`/developer/postprocessors/${this.agentId}/${postprocessorId}/version/sandbox/${sandboxVersionId}`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
 }

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

@@ -59,8 +59,26 @@ export default class PreProcessorApi extends HttpClient {
     }): Promise<ApiResponse<CreatePreProcessorResponse>>;
     /**
      * Pushes a new version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Preprocessor description
+     * @param versionData.context - Preprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
-    pushPreProcessor(preprocessorId: string, versionData: any): Promise<ApiResponse<PreProcessorVersionResponse>>;
+    pushPreProcessor(preprocessorId: string, versionData: {
+        name: string;
+        version: string;
+        description?: string;
+        context?: string;
+        preprocessorId: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<PreProcessorVersionResponse>>;
     /**
      * Retrieves all versions of a specific preprocessor
      */
@@ -95,4 +113,46 @@ export default class PreProcessorApi extends HttpClient {
      * Deletes a preprocessor
      */
     deletePreProcessor(preprocessorId: string): Promise<ApiResponse<DeletePreProcessorResponse>>;
+    /**
+     * Pushes a new sandbox (dev) version of a preprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    pushDevPreProcessor(preprocessorId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        versionId: string;
+        preprocessorId: string;
+        version: string;
+        createdAt: string;
+    }>>;
+    /**
+     * Updates an existing sandbox version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    updateDevPreProcessor(preprocessorId: string, sandboxVersionId: string, versionData: {
+        name: string;
+        version?: string;
+        description?: string;
+        context?: string;
+        code: string;
+        executeFunction: string;
+        async?: boolean;
+    }): Promise<ApiResponse<{
+        message: string;
+        versionId: string;
+    }>>;
 }

package/dist/api/preprocessor.api.service.js

@@ -27,6 +27,15 @@ export default class PreProcessorApi extends HttpClient {
     }
     /**
      * Pushes a new version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code, description, context, and async flag
+     * @param versionData.version - Version number
+     * @param versionData.code - Compressed execute function code
+     * @param versionData.executeFunction - Raw execute function code
+     * @param versionData.description - Preprocessor description
+     * @param versionData.context - Preprocessor context
+     * @param versionData.async - Async execution flag (true = background, false = blocking)
      */
     async pushPreProcessor(preprocessorId, versionData) {
         return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/version`, versionData, {
@@ -73,4 +82,30 @@ export default class PreProcessorApi extends HttpClient {
             Authorization: `Bearer ${this.apiKey}`,
         });
     }
+    /**
+     * Pushes a new sandbox (dev) version of a preprocessor
+     * Creates a new sandbox version for testing without affecting production
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param versionData - Version data including code and async flag
+     * @returns Sandbox version response with sandboxId
+     */
+    async pushDevPreProcessor(preprocessorId, versionData) {
+        return this.httpPost(`/developer/preprocessors/${this.agentId}/${preprocessorId}/version/sandbox`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
+    /**
+     * Updates an existing sandbox version of a preprocessor
+     *
+     * @param preprocessorId - The preprocessor ID
+     * @param sandboxVersionId - The sandbox version ID to update
+     * @param versionData - Updated version data
+     * @returns Update response
+     */
+    async updateDevPreProcessor(preprocessorId, sandboxVersionId, versionData) {
+        return this.httpPut(`/developer/preprocessors/${this.agentId}/${preprocessorId}/version/sandbox/${sandboxVersionId}`, versionData, {
+            Authorization: `Bearer ${this.apiKey}`,
+        });
+    }
 }

package/dist/api-exports.d.ts

@@ -29,7 +29,7 @@
 import { LuaSkill, LuaTool, LuaWebhook, LuaWebhookConfig, LuaJob, LuaJobConfig, JobSchedule, PreProcessor, PreProcessorConfig, PostProcessor, PostProcessorConfig, LuaAgent, LuaAgentConfig, env } from "./types/skill.js";
 import { Basket, BasketStatus, UpdateBasketMetadataResponse } from "./interfaces/baskets.js";
 import { OrderResponse, OrderStatus } from "./interfaces/orders.js";
-import { ChatHistoryMessage, ChatHistoryContent } from "./interfaces/chat.js";
+import { ChatHistoryMessage, ChatHistoryContent, ChatMessage, TextMessage, ImageMessage, FileMessage, PreProcessorOverride, PostProcessorOverride } from "./interfaces/chat.js";
 import { JobInstance } from "./common/job.instance.js";
 import { DeleteProductResponse, Product } from "./interfaces/product.js";
 import ProductInstance from "./common/product.instance.js";
@@ -291,6 +291,13 @@ export declare const Jobs: {
      * Creates a new job dynamically from within a tool.
      * This allows tools to schedule one-time or recurring jobs programmatically.
      *
+     * **What this does:**
+     * The server handles everything in ONE API call:
+     * 1. Creates the job
+     * 2. Creates version 1.0.0 with your execute function
+     * 3. Optionally activates the job (if activate: true)
+     * 4. Returns a JobInstance for manipulation
+     *
      * @param config - Job configuration
      * @param config.name - Unique job name
      * @param config.description - Job description
@@ -298,26 +305,37 @@ export declare const Jobs: {
      * @param config.execute - Async function to execute
      * @param config.timeout - Optional timeout in seconds
      * @param config.retry - Optional retry configuration
-     * @returns Promise resolving to created job details
+     * @param config.metadata - Optional metadata
+     * @returns Promise resolving to JobInstance (already created, versioned, and activated)
      *
      * @example
      * ```typescript
      * // Create a one-time job to check basket in 3 hours
-     * await Jobs.create({
+     * const job = await Jobs.create({
      *   name: `check-basket-${basketId}`,
      *   description: 'Check if basket was abandoned',
      *   schedule: {
      *     type: 'once',
      *     executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000)
      *   },
-     *   execute: async () => {
-     *     const basket = await Baskets.getById(basketId);
+     *   metadata: {
+     *     basketId: basketId,
+     *     checkType: 'abandoned-cart'
+     *   },
+     *   execute: async (job, user) => {
+     *     // Access user context and metadata
+     *     console.log('Checking basket for user:', user.name);
+     *     console.log('Basket ID from metadata:', metadata?.basketId);
+     *
+     *     const basket = await Baskets.getById(metadata.basketId);
      *     if (basket.status === 'active') {
      *       // Send reminder
      *     }
      *     return { checked: true };
      *   }
      * });
+     * // Job is now created, versioned as 1.0.0, and activated!
+     * console.log(`Job ${job.jobId} is active: ${job.active}`);
      * ```
      */
     create(config: {
@@ -331,6 +349,8 @@ export declare const Jobs: {
             backoffSeconds?: number;
         };
         metadata?: Record<string, any>;
+        /** Auto-activate the job after creation (default: true) */
+        activate?: boolean;
     }): Promise<JobInstance>;
     /**
      * Retrieves a job by its unique identifier
@@ -383,4 +403,4 @@ export declare const AI: {
 };
 export { LuaSkill, LuaTool, LuaWebhook, LuaWebhookConfig, LuaJob, LuaJobConfig, JobSchedule, PreProcessor, PreProcessorConfig, PostProcessor, PostProcessorConfig, LuaAgent, LuaAgentConfig, BasketStatus, OrderStatus, env };
 export { JobInstance };
-export { ChatHistoryMessage, ChatHistoryContent };
+export { ChatHistoryMessage, ChatHistoryContent, ChatMessage, TextMessage, ImageMessage, FileMessage, PreProcessorOverride, PostProcessorOverride };

package/dist/api-exports.js

@@ -378,6 +378,13 @@ export const Jobs = {
      * Creates a new job dynamically from within a tool.
      * This allows tools to schedule one-time or recurring jobs programmatically.
      *
+     * **What this does:**
+     * The server handles everything in ONE API call:
+     * 1. Creates the job
+     * 2. Creates version 1.0.0 with your execute function
+     * 3. Optionally activates the job (if activate: true)
+     * 4. Returns a JobInstance for manipulation
+     *
      * @param config - Job configuration
      * @param config.name - Unique job name
      * @param config.description - Job description
@@ -385,72 +392,78 @@ export const Jobs = {
      * @param config.execute - Async function to execute
      * @param config.timeout - Optional timeout in seconds
      * @param config.retry - Optional retry configuration
-     * @returns Promise resolving to created job details
+     * @param config.metadata - Optional metadata
+     * @returns Promise resolving to JobInstance (already created, versioned, and activated)
      *
      * @example
      * ```typescript
      * // Create a one-time job to check basket in 3 hours
-     * await Jobs.create({
+     * const job = await Jobs.create({
      *   name: `check-basket-${basketId}`,
      *   description: 'Check if basket was abandoned',
      *   schedule: {
      *     type: 'once',
      *     executeAt: new Date(Date.now() + 3 * 60 * 60 * 1000)
      *   },
-     *   execute: async () => {
-     *     const basket = await Baskets.getById(basketId);
+     *   metadata: {
+     *     basketId: basketId,
+     *     checkType: 'abandoned-cart'
+     *   },
+     *   execute: async (job, user) => {
+     *     // Access user context and metadata
+     *     console.log('Checking basket for user:', user.name);
+     *     console.log('Basket ID from metadata:', metadata?.basketId);
+     *
+     *     const basket = await Baskets.getById(metadata.basketId);
      *     if (basket.status === 'active') {
      *       // Send reminder
      *     }
      *     return { checked: true };
      *   }
      * });
+     * // Job is now created, versioned as 1.0.0, and activated!
+     * console.log(`Job ${job.jobId} is active: ${job.active}`);
      * ```
      */
     async create(config) {
         const instance = await getJobInstance();
         // Convert the execute function to a string
         const executeString = config.execute.toString();
-        // Step 1: Create the job
+        console.log('Creating Job');
+        // Create the job with initial version and activation in one call
         const createResult = await instance.createJobInstance({
+            dynamic: true,
             name: config.name,
             description: config.description,
             context: config.description || '',
             schedule: config.schedule,
             timeout: config.timeout,
             retry: config.retry,
-            metadata: config.metadata
+            metadata: config.metadata,
+            // Include initial version data for automatic version creation
+            version: {
+                version: '1.0.0',
+                description: config.description,
+                context: config.description || '',
+                code: '', // Will be set by server
+                executeFunction: executeString,
+                timeout: config.timeout,
+                retry: config.retry,
+                metadata: config.metadata
+            },
+            // Activate immediately
+            activate: config.activate ?? true
         });
         const jobId = createResult.jobId;
-        // Step 2: Push the initial version with execute function
-        const pushResult = await instance.pushJob(jobId, {
-            name: config.name,
-            version: '1.0.0',
-            description: config.description,
-            context: config.description || '',
-            jobId: jobId,
-            schedule: config.schedule,
-            timeout: config.timeout,
-            retry: config.retry,
-            executeFunction: executeString,
-            metadata: config.metadata
-        });
-        if (!pushResult.success) {
-            throw new Error(`Failed to push job version: ${pushResult.error?.message}`);
-        }
-        // Step 3: Activate the job so it starts running
-        const activateResult = await instance.activateJob(jobId);
-        if (!activateResult.success) {
-            console.warn(`Job created but activation failed: ${activateResult.error?.message}`);
-        }
-        // Step 4: Return a JobInstance for easy manipulation
+        // Server has created the job, version, and activated it
+        // Return a JobInstance for easy manipulation
         return new JobInstance(instance, {
             id: jobId,
             jobId: jobId,
             name: config.name,
             schedule: config.schedule,
             metadata: config.metadata || {},
-            active: activateResult.success
+            active: config.activate ?? true
         });
     },
     /**

package/dist/commands/chat.js

@@ -8,8 +8,8 @@ import { loadApiKey, checkApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
 import { compileCommand } from './compile.js';
-import { pushSkillsToSandbox } from '../utils/dev-api.js';
-import { getAllSandboxSkillIds } from '../utils/sandbox-storage.js';
+import { pushSkillsToSandbox, pushProcessorsToSandbox } from '../utils/dev-api.js';
+import { getAllSandboxSkillIds, getAllSandboxPreProcessorIds, getAllSandboxPostProcessorIds } from '../utils/sandbox-storage.js';
 import ChatApi from '../api/chat.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 import { readDeployJson, validateConfig, validateDeployData, validateAgentConfig, } from '../utils/dev-helpers.js';
@@ -66,7 +66,7 @@ export async function chatCommand() {
     }, "chat");
 }
 /**
- * Sets up the sandbox environment by compiling and pushing skills
+ * Sets up the sandbox environment by compiling and pushing skills, preprocessors, and postprocessors
  */
 async function setupSandboxEnvironment(chatEnv, config) {
     writeProgress("🔄 Setting up sandbox environment...");
@@ -84,8 +84,31 @@ async function setupSandboxEnvironment(chatEnv, config) {
         process.exit(1);
     }
     writeSuccess(`✅ Pushed ${Object.keys(sandboxIds).length} skills to sandbox`);
+    // Push preprocessors and postprocessors to sandbox
+    const fs = await import('fs');
+    const path = await import('path');
+    const preprocessorsPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
+    const postprocessorsPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
+    let bundledPreProcessors = [];
+    let bundledPostProcessors = [];
+    if (fs.existsSync(preprocessorsPath)) {
+        bundledPreProcessors = JSON.parse(fs.readFileSync(preprocessorsPath, 'utf8'));
+    }
+    if (fs.existsSync(postprocessorsPath)) {
+        bundledPostProcessors = JSON.parse(fs.readFileSync(postprocessorsPath, 'utf8'));
+    }
+    if (bundledPreProcessors.length > 0 || bundledPostProcessors.length > 0) {
+        writeProgress("🔄 Pushing processors to sandbox...");
+        const processorCounts = await pushProcessorsToSandbox(chatEnv.apiKey, chatEnv.agentId, config, bundledPreProcessors, bundledPostProcessors, true);
+        if (processorCounts.preprocessors > 0 || processorCounts.postprocessors > 0) {
+            writeSuccess(`✅ Pushed ${processorCounts.preprocessors} preprocessor(s) and ${processorCounts.postprocessors} postprocessor(s) to sandbox`);
+        }
+    }
     // Store deploy data for skill overrides
     chatEnv.deployData = deployData;
+    // Get processor overrides for sandbox
+    chatEnv.preprocessorOverrides = await getAllSandboxPreProcessorIds(config);
+    chatEnv.postprocessorOverrides = await getAllSandboxPostProcessorIds(config);
     // Check for persona in config
     if (config.agent?.persona) {
         chatEnv.persona = config.agent.persona;
@@ -198,7 +221,9 @@ async function sendSandboxMessage(chatEnv, message) {
             }
         ],
         navigate: true,
-        skillOverride: allSkillOverrides
+        skillOverride: allSkillOverrides,
+        preprocessorOverride: chatEnv.preprocessorOverrides || [],
+        postprocessorOverride: chatEnv.postprocessorOverrides || []
     };
     // Add persona override if available
     if (chatEnv.persona) {
@@ -224,7 +249,9 @@ async function sendProductionMessage(chatEnv, message) {
             }
         ],
         navigate: true,
-        skillOverride: []
+        skillOverride: [],
+        preprocessorOverride: [],
+        postprocessorOverride: []
     };
     const chatApi = new ChatApi(BASE_URLS.CHAT, chatEnv.apiKey);
     const response = await chatApi.sendMessage(chatEnv.agentId, chatRequest);

package/dist/commands/compile.js

@@ -78,9 +78,23 @@ export async function compileCommand() {
         const tools = await detectTools(indexFile, project, skillFilePaths);
         writeProgress(`📦 Found ${tools.length} tools to bundle...`);
         // Step 3: Bundle each tool and extract metadata
+        const { preBundleJobsInSource, replaceJobPlaceholders } = await import('../utils/pre-bundle-jobs.js');
         for (const tool of tools) {
-            await bundleTool(tool, distDir);
-            await extractExecuteCode(tool, project);
+            // Step 3a: Pre-bundle any Jobs.create() in the tool source
+            const { modifiedSource, jobBundles } = await preBundleJobsInSource(tool.filePath, project, distDir);
+            // Step 3b: Bundle the tool (with placeholders for job execute functions)
+            await bundleTool(tool, distDir, modifiedSource);
+            // Step 3c: Replace placeholders in the bundled tool file
+            if (jobBundles.size > 0) {
+                const toolBundlePath = path.join(distDir, 'tools', `${tool.className}.js`);
+                if (fs.existsSync(toolBundlePath)) {
+                    let bundledToolCode = fs.readFileSync(toolBundlePath, 'utf8');
+                    bundledToolCode = replaceJobPlaceholders(bundledToolCode, jobBundles);
+                    fs.writeFileSync(toolBundlePath, bundledToolCode);
+                }
+            }
+            // Step 3d: Extract execute code
+            await extractExecuteCode(tool, project, distDir);
         }
         // Step 4: Bundle the main index file
         await bundleMainIndex(indexPath, distDir);