rentabots-sdk 1.7.1 → 1.7.7

package/dist/index.d.ts

@@ -1,12 +1,6 @@
 import { z } from 'zod';
 import { EventEmitter } from 'events';
 import { ChildProcess } from 'child_process';
-export interface LLMConfig {
-    provider: 'openclaw' | 'openai' | 'anthropic' | 'google' | 'groq' | 'mistral' | 'custom';
-    apiKey?: string;
-    model?: string;
-    baseUrl?: string;
-}
 export declare const JobStatusSchema: z.ZodEnum<{
     open: "open";
     in_progress: "in_progress";
@@ -59,8 +53,6 @@ export interface AgentOptions {
     workspaceRoot?: string;
     workerScriptPath?: string;
     commandWhitelist?: string[];
-    llm?: LLMConfig;
-    capabilities?: string[];
 }
 export interface ExecuteOptions {
     timeout?: number;
@@ -74,7 +66,7 @@ export interface AutopilotOptions {
     bidTemplate?: string;
 }
 /**
- * 🦀 RENTABOTS MASTER SDK (v1.7.1)
+ * 🦀 RENTABOTS MASTER SDK (v1.5.7)
  * Robust, production-grade autonomous agent runtime.
  * UPDATES:
  * - Agent Isolation Protocol (Private workspaces).
@@ -86,7 +78,7 @@ export declare class Agent extends EventEmitter {
     private apiKey;
     readonly baseUrl: string;
     readonly socketUrl: string;
-    agentId: string | null;
+    private agentId;
     private api;
     private socket;
     private debug;
@@ -98,11 +90,9 @@ export declare class Agent extends EventEmitter {
     completedMissions: Map<string, Job>;
     private bidCache;
     private seenMessages;
-    workers: Map<string, ChildProcess>;
+    private workers;
     private autopilotTimer;
-    autopilotPaused: boolean;
-    private llmConfig;
-    private capabilities;
+    private autopilotPaused;
     constructor(options?: AgentOptions);
     /**
      * Establish grid connection and initialize sockets.
@@ -135,8 +125,40 @@ export declare class Agent extends EventEmitter {
         error: any;
         jobId?: undefined;
     }>;
+    setProgress(jobId: string, percent: number): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    createRepo(jobId: string, name?: string): Promise<{
+        success: boolean;
+        repo?: any;
+        error?: string;
+    }>;
+    getRepo(jobId: string): Promise<{
+        success: boolean;
+        exists: boolean;
+        repo?: any;
+        error?: string;
+    }>;
+    uploadRepoFile(jobId: string, filePath: string, content: string | Buffer, isBlob?: boolean): Promise<{
+        success: boolean;
+        repoId?: string;
+        error?: string;
+    }>;
+    downloadRepoFile(jobId: string, filePath: string): Promise<{
+        success: boolean;
+        content?: string;
+        isBlob?: boolean;
+        error?: string;
+    }>;
     private isBinaryFile;
     deliver(jobId: string, files: string[]): Promise<void>;
+    runTests(jobId: string, command?: string): Promise<{
+        success: boolean;
+        passed: boolean;
+        output?: string;
+        error?: string;
+    }>;
     verifyDeliverables(jobId: string): Promise<{
         success: boolean;
         verified: boolean;
@@ -147,16 +169,26 @@ export declare class Agent extends EventEmitter {
     preDeliveryCheck(jobId: string): Promise<{
         canDeliver: boolean;
         checks: any[];
+        recommendations?: string[];
     }>;
     markComplete(jobId: string): Promise<any>;
-    initLLM(config?: Partial<LLMConfig>): Promise<void>;
+    private llmClient?;
+    initLLM(config?: {
+        provider?: 'groq' | 'openai' | 'anthropic' | 'google' | 'nvidia';
+        apiKey?: string;
+        model?: string;
+    }): Promise<void>;
     generate(prompt: string, options?: {
+        model?: string;
+        temperature?: number;
+        maxTokens?: number;
         system?: string;
     }): Promise<{
         success: boolean;
         text?: string;
         error?: string;
     }>;
+    askLLM(systemPrompt: string, userPrompt: string): Promise<string | null>;
     analyzeRequirements(job: Job): Promise<{
         success: boolean;
         requirements?: any;
@@ -176,106 +208,6 @@ export declare class Agent extends EventEmitter {
     bid(jobId: string, amount: number, message: string): Promise<any>;
     sendMessage(jobId: string, content: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     setTyping(jobId: string, isTyping?: boolean): Promise<void>;
-    /**
-     * Update mission progress (0-100%)
-     */
-    setProgress(jobId: string, progress: number): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    /**
-     * Initialize isolated workspace for a mission, returns the path
-     */
-    initializeMission(jobId: string): Promise<string>;
-    /**
-     * One-shot bid search: find open jobs matching skills and bid on them
-     */
-    findAndBid(options?: {
-        skills?: string[];
-        minBudget?: number;
-        bidMessage?: string;
-    }): Promise<{
-        success: boolean;
-        bidsPlaced: number;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        bidsPlaced?: undefined;
-    }>;
-    /**
-     * Notify the agent's human owner (via API)
-     */
-    notifyOwner(message: string): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    /**
-     * Log a message to the agent's server-side log
-     */
-    log(message: string, level?: string): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    /**
-     * Alias: triggered when human hires this agent
-     */
-    onHired(callback: (job: Job) => void): void;
-    /**
-     * Alias: triggered on incoming chat message
-     */
-    onMessage(callback: (msg: Message) => void): void;
-    /**
-     * Upload a deliverable file to a mission
-     */
-    uploadDeliverable(jobId: string, url: string, name: string): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    /**
-     * Create a private repository for a mission
-     */
-    createRepo(jobId: string, name?: string): Promise<{
-        success: boolean;
-        repo?: any;
-        error?: string;
-    }>;
-    /**
-     * Upload files to a mission's repository
-     */
-    uploadToRepo(jobId: string, files: {
-        path: string;
-        content: string;
-    }[]): Promise<({
-        path: string;
-        success: boolean;
-        error?: undefined;
-    } | {
-        path: string;
-        success: boolean;
-        error: any;
-    })[]>;
-    uploadRepoFile(jobId: string, filePath: string, content: string | Buffer, isBlob?: boolean): Promise<{
-        success: boolean;
-        repoId?: string;
-        error?: string;
-    }>;
-    /**
-     * Check if a repository exists for a mission and get its info
-     */
-    getRepo(jobId: string): Promise<{
-        success: boolean;
-        exists: boolean;
-        repo?: any;
-        error?: string;
-    }>;
-    /**
-     * Ask the LLM brain a question. Works with OpenClaw or any custom API provider.
-     * @param systemPrompt System-level instructions
-     * @param userMessage The user/human message to respond to
-     * @returns The LLM response text, or null on failure
-     */
-    askLLM(systemPrompt: string, userMessage: string): Promise<string | null>;
-    /**
-     * OpenClaw bridge: sends query to local OpenClaw instance
-     */
-    private askOpenClaw;
-    /**
-     * Custom LLM API: supports OpenAI-compatible endpoints (OpenAI, Groq, Mistral, etc.)
-     * Also supports Anthropic and Google with adapter logic.
-     */
-    private askCustomLLM;
     private enrichJob;
     private syncFromCloud;
     private loadState;

package/dist/index.js

@@ -38,7 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = exports.MessageSchema = exports.JobSchema = exports.JobStatusSchema = void 0;
 const axios_1 = __importDefault(require("axios"));
-// import { LLMClient } from "./llm"; // Removed missing module
+const llm_1 = require("./llm");
 const socket_io_client_1 = require("socket.io-client");
 const zod_1 = require("zod");
 const events_1 = require("events");
@@ -46,22 +46,6 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const sanitizer_1 = require("./utils/sanitizer");
-const DEFAULT_MODELS = {
-    openclaw: 'default',
-    openai: 'gpt-4o-mini',
-    anthropic: 'claude-sonnet-4-20250514',
-    google: 'gemini-2.0-flash',
-    groq: 'llama-3.3-70b-versatile',
-    mistral: 'mistral-large-latest',
-    custom: 'gpt-4o-mini',
-};
-const PROVIDER_URLS = {
-    openai: 'https://api.openai.com/v1',
-    anthropic: 'https://api.anthropic.com/v1',
-    google: 'https://generativelanguage.googleapis.com/v1beta',
-    groq: 'https://api.groq.com/openai/v1',
-    mistral: 'https://api.mistral.ai/v1',
-};
 // --- SCHEMAS & TYPES ---
 exports.JobStatusSchema = zod_1.z.enum(['open', 'in_progress', 'completed', 'archived', 'disputed']);
 exports.JobSchema = zod_1.z.object({
@@ -87,14 +71,14 @@ exports.MessageSchema = zod_1.z.object({
     })
 });
 // --- CORE SDK ENGINE ---
-let SDK_VERSION = '1.7.1'; // BUMP to v1.7.1
+let SDK_VERSION = '1.7.7'; // fallback when package.json is unavailable
 try {
     const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
     SDK_VERSION = pkg.version;
 }
 catch (e) { }
 /**
- * 🦀 RENTABOTS MASTER SDK (v1.7.1)
+ * 🦀 RENTABOTS MASTER SDK (v1.5.7)
  * Robust, production-grade autonomous agent runtime.
  * UPDATES:
  * - Agent Isolation Protocol (Private workspaces).
@@ -116,32 +100,11 @@ class Agent extends events_1.EventEmitter {
         // Autopilot state
         this.autopilotTimer = null;
         this.autopilotPaused = false;
-        this.apiKey = options.apiKey || process.env.RENTABOTS_API_KEY || process.env.RENTABOTS_SECRET_KEY || '';
-        this.baseUrl = (options.baseUrl || process.env.RENTABOTS_API_URL || 'https://rentabots.com/api').replace(/\/$/, '');
-        // --- 🛡️ FIX: Robust Socket URL Construction ---
-        // Don't rely on brittle .replace('/api', ''). Use proper URL parsing.
-        if (process.env.RENTABOTS_SOCKET_URL) {
-            this.socketUrl = process.env.RENTABOTS_SOCKET_URL.replace(/\/$/, '');
-        }
-        else {
-            try {
-                const parsed = new URL(this.baseUrl);
-                this.socketUrl = `${parsed.protocol}//${parsed.host}`;
-            }
-            catch {
-                this.socketUrl = this.baseUrl.replace(/\/api.*$/, '');
-            }
-        }
+        this.apiKey = options.apiKey || process.env.RENTABOTS_API_KEY || '';
+        this.baseUrl = (options.baseUrl || 'https://rentabots.com/api').replace(/\/$/, '');
+        this.socketUrl = (process.env.RENTABOTS_SOCKET_URL || this.baseUrl.replace('/api', '')).replace(/\/$/, '');
         this.debug = options.debug || false;
         this.commandWhitelist = options.commandWhitelist || null;
-        this.capabilities = options.capabilities || [];
-        // --- 🧠 LLM CONFIGURATION ---
-        this.llmConfig = options.llm || {
-            provider: process.env.LLM_PROVIDER || 'openclaw',
-            apiKey: process.env.LLM_API_KEY || '',
-            model: process.env.LLM_MODEL || '',
-            baseUrl: process.env.LLM_BASE_URL || '',
-        };
         // --- 🛡️ AGENT ISOLATION ---
         // By default, create a unique workspace root if not provided.
         // We will finalize this in connect() once we have the agentId.
@@ -372,26 +335,11 @@ class Agent extends events_1.EventEmitter {
     async spawnWorker(job) {
         if (!fs.existsSync(this.workerScriptPath))
             throw new Error("Worker script not found.");
-        // --- 🛡️ FIX: Write job data to temp file instead of CLI args ---
-        // CLI args have OS length limits (~8KB on Windows). Long job descriptions
-        // would cause silent spawn failures or data truncation.
-        const jobDataPath = path.join(this.workspaceRoot, `_job_${job.id}.json`);
-        fs.writeFileSync(jobDataPath, JSON.stringify(job));
-        const worker = (0, child_process_1.fork)(this.workerScriptPath, [jobDataPath], {
-            // --- 🛡️ FIX: stdin set to 'ignore' for background/daemon safety ---
-            // 'inherit' causes crashes when no TTY is available (nohup, systemd, PM2).
-            stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        const worker = (0, child_process_1.fork)(this.workerScriptPath, [JSON.stringify(job)], {
             env: { ...process.env, RENTABOTS_API_KEY: this.apiKey }
         });
         this.workers.set(job.id, worker);
-        worker.on('exit', () => {
-            this.workers.delete(job.id);
-            // Cleanup temp file
-            try {
-                fs.unlinkSync(jobDataPath);
-            }
-            catch { }
-        });
+        worker.on('exit', () => this.workers.delete(job.id));
         return worker;
     }
     // --- ⚡ ACTIONS ---
@@ -464,6 +412,71 @@ class Agent extends events_1.EventEmitter {
             return { success: false, error: e.response?.data?.error || e.message };
         }
     }
+    // --- 📊 PROGRESS TRACKING ---
+    async setProgress(jobId, percent) {
+        try {
+            const progress = Math.min(100, Math.max(0, Math.round(percent)));
+            await this.api.post(`jobs/${jobId}/progress`, { progress });
+            const job = this.activeMissions.get(jobId);
+            if (job) {
+                job.progress = progress;
+                this.activeMissions.set(jobId, job);
+                this.saveState();
+            }
+            return { success: true };
+        }
+        catch (e) {
+            return { success: false, error: e.response?.data?.error || e.message };
+        }
+    }
+    // --- 📦 REPO MANAGEMENT ---
+    async createRepo(jobId, name) {
+        try {
+            const res = await this.api.post(`jobs/${jobId}/repo`, { name });
+            this.logInternal(`Repo created: ${res.data.repo?.name}`);
+            return { success: true, repo: res.data.repo };
+        }
+        catch (e) {
+            return { success: false, error: e.response?.data?.error || e.message };
+        }
+    }
+    async getRepo(jobId) {
+        try {
+            const res = await this.api.get(`jobs/${jobId}/repo`);
+            return { success: true, exists: res.data.exists, repo: res.data.repo };
+        }
+        catch (e) {
+            if (e.response?.status === 404)
+                return { success: true, exists: false };
+            return { success: false, exists: false, error: e.response?.data?.error || e.message };
+        }
+    }
+    async uploadRepoFile(jobId, filePath, content, isBlob = false) {
+        try {
+            let finalContent;
+            if (Buffer.isBuffer(content)) {
+                finalContent = content.toString('base64');
+                isBlob = true;
+            }
+            else {
+                finalContent = String(content);
+            }
+            const res = await this.api.post(`jobs/${jobId}/repo/files`, { path: filePath, content: finalContent, isBlob });
+            return { success: true, repoId: res.data.repoId };
+        }
+        catch (e) {
+            return { success: false, error: e.response?.data?.error || e.message };
+        }
+    }
+    async downloadRepoFile(jobId, filePath) {
+        try {
+            const res = await this.api.get(`jobs/${jobId}/repo/files`, { params: { path: filePath } });
+            return { success: true, content: res.data.content, isBlob: res.data.isBlob };
+        }
+        catch (e) {
+            return { success: false, error: e.response?.data?.error || e.message };
+        }
+    }
     isBinaryFile(filePath) {
         const textExts = ['.js', '.ts', '.json', '.md', '.txt', '.html', '.css', '.yml', '.yaml', '.toml'];
         return !textExts.includes(path.extname(filePath).toLowerCase());
@@ -479,6 +492,29 @@ class Agent extends events_1.EventEmitter {
         }
     }
     // --- ✅ VERIFICATION FLOW ---
+    // --- 🧪 TEST RUNNER ---
+    async runTests(jobId, command = 'npm test') {
+        try {
+            const cwd = path.join(this.workspaceRoot, jobId);
+            if (!fs.existsSync(cwd)) {
+                return { success: false, passed: false, error: 'Workspace not found' };
+            }
+            // Check if test command exists in package.json
+            const pkgPath = path.join(cwd, 'package.json');
+            let testCmd = command;
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                if (!pkg.scripts?.test && command === 'npm test') {
+                    return { success: true, passed: true, output: 'No tests configured' };
+                }
+            }
+            const result = await this.execute(jobId, testCmd.split(' ')[0], testCmd.split(' ').slice(1), { timeout: 120000 });
+            return { success: true, passed: result.exitCode === 0, output: result.output };
+        }
+        catch (e) {
+            return { success: false, passed: false, error: e.message };
+        }
+    }
     async verifyDeliverables(jobId) {
         try {
             const cwd = path.join(this.workspaceRoot, jobId);
@@ -510,10 +546,25 @@ class Agent extends events_1.EventEmitter {
     }
     async preDeliveryCheck(jobId) {
         const verify = await this.verifyDeliverables(jobId);
-        const checks = [{ name: 'Deliverables', passed: verify.verified, details: verify.files?.length + ' files' }];
+        const testResult = await this.runTests(jobId);
+        const checks = [
+            { name: 'Deliverables', passed: verify.verified, details: (verify.files?.length || 0) + ' files' },
+            { name: 'Tests', passed: testResult.passed, details: testResult.passed ? 'Passed' : 'Failed/No tests' }
+        ];
         const job = this.activeMissions.get(jobId);
-        checks.push({ name: 'Progress', passed: (job?.progress || 0) >= 80, details: (job?.progress || 0) + '%' });
-        return { canDeliver: checks.every(c => c.passed), checks };
+        if (job?.progress && job.progress > 0) {
+            checks.push({ name: 'Progress', passed: job.progress >= 80, details: job.progress + '%' });
+        }
+        const recommendations = [];
+        if (!verify.verified && verify.issues)
+            recommendations.push(...verify.issues);
+        if (!testResult.passed && testResult.output)
+            recommendations.push('Tests failing: ' + testResult.output.slice(0, 100));
+        return {
+            canDeliver: checks.every(c => c.passed),
+            checks,
+            recommendations: recommendations.length > 0 ? recommendations : undefined
+        };
     }
     async markComplete(jobId) {
         const res = await this.api.post(`jobs/${jobId}/complete`, { userId: this.agentId, role: 'agent' });
@@ -526,21 +577,31 @@ class Agent extends events_1.EventEmitter {
         }
         return res.data;
     }
-    // --- 🧠 LLM INTEGRATION ---
     async initLLM(config) {
-        if (config) {
-            this.llmConfig = { ...this.llmConfig, ...config };
-        }
+        this.llmClient = new llm_1.LLMClient(config);
     }
     async generate(prompt, options = {}) {
-        const res = await this.askLLM(options.system || 'You are a helpful assistant.', prompt);
-        if (res)
-            return { success: true, text: res };
-        return { success: false, error: 'LLM request failed' };
+        if (!this.llmClient) {
+            try {
+                this.llmClient = new llm_1.LLMClient();
+            }
+            catch (e) {
+                return { success: false, error: e.message };
+            }
+        }
+        return this.llmClient.generate(prompt, options);
+    }
+    async askLLM(systemPrompt, userPrompt) {
+        const res = await this.generate(userPrompt, {
+            system: systemPrompt,
+            temperature: 0.4,
+            maxTokens: 1200,
+        });
+        return res.success ? (res.text || null) : null;
     }
     async analyzeRequirements(job) {
         const prompt = 'Analyze job, return JSON with techStack, features, deliverables, timeline, risks. Title: ' + job.title + ' Desc: ' + job.description.slice(0, 500);
-        const res = await this.generate(prompt, { system: 'Extract requirements as JSON' });
+        const res = await this.generate(prompt, { system: 'Extract requirements as JSON', temperature: 0.3 });
         if (!res.success)
             return res;
         try {
@@ -552,14 +613,14 @@ class Agent extends events_1.EventEmitter {
         }
     }
     async codeGenerator(prompt, language = 'javascript') {
-        const res = await this.generate(prompt, { system: 'Output only ' + language + ' code' });
+        const res = await this.generate(prompt, { system: 'Output only ' + language + ' code', temperature: 0.2, maxTokens: 4000 });
         if (!res.success)
             return res;
         const code = res.text?.match(/```(?:\w+)?\n?([\s\S]*?)```/)?.[1] || res.text;
         return { success: true, code: code?.trim() };
     }
     async reviewCode(code, requirements) {
-        const res = await this.generate('Review code. Reqs: ' + requirements + ' Code: ' + code.slice(0, 2000), { system: 'Code reviewer' });
+        const res = await this.generate('Review code. Reqs: ' + requirements + ' Code: ' + code.slice(0, 2000), { system: 'Code reviewer', temperature: 0.3 });
         if (!res.success)
             return { success: false, passed: false, error: res.error };
         const passed = !!(res.text?.toUpperCase().includes('PASS') && !res.text?.toUpperCase().includes('FAIL'));
@@ -587,278 +648,6 @@ class Agent extends events_1.EventEmitter {
     async setTyping(jobId, isTyping = true) {
         this.socket?.emit('typing_state', { jobId, isTyping });
     }
-    // --- 📡 MISSING METHODS (Fixed in v1.6.0) ---
-    /**
-     * Update mission progress (0-100%)
-     */
-    async setProgress(jobId, progress) {
-        try {
-            const res = await this.api.post(`jobs/${jobId}/progress`, { progress, agentId: this.agentId });
-            const job = this.activeMissions.get(jobId);
-            if (job) {
-                job.progress = progress;
-                this.activeMissions.set(jobId, job);
-                this.saveState();
-            }
-            return { success: true };
-        }
-        catch (e) {
-            this.logInternal(`Failed to update progress for ${jobId}: ${e.message}`);
-            return { success: false, error: e.message };
-        }
-    }
-    /**
-     * Initialize isolated workspace for a mission, returns the path
-     */
-    async initializeMission(jobId) {
-        const cwd = path.join(this.workspaceRoot, jobId);
-        if (!fs.existsSync(cwd))
-            fs.mkdirSync(cwd, { recursive: true });
-        this.logInternal(`Mission workspace initialized: ${cwd}`);
-        return cwd;
-    }
-    /**
-     * One-shot bid search: find open jobs matching skills and bid on them
-     */
-    async findAndBid(options = {}) {
-        try {
-            const res = await this.api.get('jobs?status=open');
-            const jobs = res.data.data.map((j) => this.enrichJob(j));
-            const skills = options.skills || this.capabilities || [];
-            let bidCount = 0;
-            for (const job of jobs) {
-                if (this.bidCache.has(job.id))
-                    continue;
-                if (options.minBudget && job.budgetAmount < options.minBudget)
-                    continue;
-                const matches = skills.length === 0 || skills.some(s => job.title.toLowerCase().includes(s.toLowerCase()) ||
-                    job.description.toLowerCase().includes(s.toLowerCase()));
-                if (matches) {
-                    const msg = options.bidMessage || `I am an autonomous agent with ${this.completedMissions.size} completed missions. Skills: ${skills.join(', ')}. Ready to deliver.`;
-                    await this.bid(job.id, job.budgetAmount, msg);
-                    bidCount++;
-                }
-            }
-            this.logInternal(`findAndBid: Placed ${bidCount} bids on ${jobs.length} open jobs.`);
-            return { success: true, bidsPlaced: bidCount };
-        }
-        catch (e) {
-            this.logInternal(`findAndBid failed: ${e.message}`);
-            return { success: false, error: e.message };
-        }
-    }
-    /**
-     * Notify the agent's human owner (via API)
-     */
-    async notifyOwner(message) {
-        try {
-            return await this.api.post('agents/me/notify', { message });
-        }
-        catch (e) {
-            this.logInternal(`notifyOwner failed: ${e.message}`);
-        }
-    }
-    /**
-     * Log a message to the agent's server-side log
-     */
-    async log(message, level = 'INFO') {
-        this.logInternal(`[${level}] ${message}`);
-        try {
-            return await this.api.post('agents/me/logs', { message, level });
-        }
-        catch (e) {
-            // Swallow — logging should never crash the agent
-        }
-    }
-    /**
-     * Alias: triggered when human hires this agent
-     */
-    onHired(callback) {
-        this.on('assignment', callback);
-    }
-    /**
-     * Alias: triggered on incoming chat message
-     */
-    onMessage(callback) {
-        this.on('message', callback);
-    }
-    /**
-     * Upload a deliverable file to a mission
-     */
-    async uploadDeliverable(jobId, url, name) {
-        try {
-            return await this.api.post(`jobs/${jobId}/files`, {
-                url,
-                name,
-                type: 'deliverable',
-                userId: this.agentId
-            });
-        }
-        catch (e) {
-            this.logInternal(`uploadDeliverable failed: ${e.message}`);
-        }
-    }
-    /**
-     * Create a private repository for a mission
-     */
-    async createRepo(jobId, name) {
-        try {
-            const res = await this.api.post(`jobs/${jobId}/repo`, { name });
-            this.logInternal(`Repository created for job ${jobId}`);
-            return { success: true, repo: res.data.repo };
-        }
-        catch (e) {
-            this.logInternal(`createRepo failed: ${e.message}`);
-            return { success: false, error: e.message };
-        }
-    }
-    /**
-     * Upload files to a mission's repository
-     */
-    async uploadToRepo(jobId, files) {
-        const results = [];
-        for (const file of files) {
-            try {
-                const res = await this.api.post(`jobs/${jobId}/repo/files`, file);
-                results.push({ path: file.path, success: true });
-            }
-            catch (e) {
-                results.push({ path: file.path, success: false, error: e.message });
-            }
-        }
-        return results;
-    }
-    async uploadRepoFile(jobId, filePath, content, isBlob = false) {
-        try {
-            let finalContent;
-            if (Buffer.isBuffer(content)) {
-                finalContent = content.toString('base64');
-                isBlob = true;
-            }
-            else {
-                finalContent = String(content);
-            }
-            const res = await this.api.post(`jobs/${jobId}/repo/files`, { path: filePath, content: finalContent, isBlob });
-            return { success: true, repoId: res.data.repoId };
-        }
-        catch (e) {
-            return { success: false, error: e.response?.data?.error || e.message };
-        }
-    }
-    /**
-     * Check if a repository exists for a mission and get its info
-     */
-    async getRepo(jobId) {
-        try {
-            const res = await this.api.get(`jobs/${jobId}/repo`);
-            return { success: true, exists: res.data.exists, repo: res.data.repo };
-        }
-        catch (e) {
-            if (e.response?.status === 404)
-                return { success: true, exists: false };
-            return { success: false, exists: false, error: e.response?.data?.error || e.message };
-        }
-    }
-    // --- 🧠 LLM ABSTRACTION LAYER ---
-    /**
-     * Ask the LLM brain a question. Works with OpenClaw or any custom API provider.
-     * @param systemPrompt System-level instructions
-     * @param userMessage The user/human message to respond to
-     * @returns The LLM response text, or null on failure
-     */
-    async askLLM(systemPrompt, userMessage) {
-        const provider = this.llmConfig.provider;
-        if (provider === 'openclaw') {
-            return this.askOpenClaw(systemPrompt, userMessage);
-        }
-        else {
-            return this.askCustomLLM(systemPrompt, userMessage);
-        }
-    }
-    /**
-     * OpenClaw bridge: sends query to local OpenClaw instance
-     */
-    async askOpenClaw(systemPrompt, userMessage) {
-        return new Promise((resolve) => {
-            const fullQuery = `${systemPrompt}\n\nUser: ${userMessage}`;
-            const child = (0, child_process_1.spawn)('openclaw', ['session:chat', fullQuery], {
-                timeout: 60000,
-                shell: false
-            });
-            let output = '';
-            child.stdout?.on('data', (d) => output += d.toString());
-            child.stderr?.on('data', (d) => output += d.toString());
-            child.on('close', (code) => {
-                if (code === 0 && output.trim())
-                    resolve(output.trim());
-                else
-                    resolve(null);
-            });
-            child.on('error', () => resolve(null));
-        });
-    }
-    /**
-     * Custom LLM API: supports OpenAI-compatible endpoints (OpenAI, Groq, Mistral, etc.)
-     * Also supports Anthropic and Google with adapter logic.
-     */
-    async askCustomLLM(systemPrompt, userMessage) {
-        const provider = this.llmConfig.provider;
-        const apiKey = this.llmConfig.apiKey;
-        const model = this.llmConfig.model || DEFAULT_MODELS[provider] || 'gpt-4o-mini';
-        const baseUrl = this.llmConfig.baseUrl || PROVIDER_URLS[provider];
-        if (!apiKey) {
-            this.logInternal('LLM API key not configured. Falling back to basic responses.');
-            return null;
-        }
-        try {
-            if (provider === 'anthropic') {
-                // Anthropic uses a different API format
-                const res = await axios_1.default.post(`${baseUrl}/messages`, {
-                    model,
-                    max_tokens: 1024,
-                    system: systemPrompt,
-                    messages: [{ role: 'user', content: userMessage }]
-                }, {
-                    headers: {
-                        'x-api-key': apiKey,
-                        'anthropic-version': '2023-06-01',
-                        'Content-Type': 'application/json'
-                    },
-                    timeout: 30000
-                });
-                return res.data.content?.[0]?.text || null;
-            }
-            else if (provider === 'google') {
-                // Google Gemini API
-                const res = await axios_1.default.post(`${baseUrl}/models/${model}:generateContent?key=${apiKey}`, {
-                    contents: [{ parts: [{ text: `${systemPrompt}\n\n${userMessage}` }] }]
-                }, { timeout: 30000 });
-                return res.data.candidates?.[0]?.content?.parts?.[0]?.text || null;
-            }
-            else {
-                // OpenAI-compatible (OpenAI, Groq, Mistral, Custom)
-                const res = await axios_1.default.post(`${baseUrl}/chat/completions`, {
-                    model,
-                    messages: [
-                        { role: 'system', content: systemPrompt },
-                        { role: 'user', content: userMessage }
-                    ],
-                    max_tokens: 1024
-                }, {
-                    headers: {
-                        'Authorization': `Bearer ${apiKey}`,
-                        'Content-Type': 'application/json'
-                    },
-                    timeout: 30000
-                });
-                return res.data.choices?.[0]?.message?.content || null;
-            }
-        }
-        catch (e) {
-            this.logInternal(`LLM call failed (${provider}): ${e.message}`);
-            return null;
-        }
-    }
     // --- UTILS ---
     enrichJob(raw) {
         return {

package/dist/llm.d.ts

@@ -1,34 +1,36 @@
-/**
- * LLM Provider Configuration
- * Agents use their own API keys - no server proxy needed
- */
-export interface LLMConfig {
-    provider: 'groq' | 'openai' | 'anthropic' | 'google' | 'nvidia';
-    apiKey: string;
-    baseUrl?: string;
-    model?: string;
-}
-export interface LLMResponse {
-    success: boolean;
-    text?: string;
-    error?: string;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-    };
-}
-export declare class LLMClient {
-    private config;
-    private client;
-    constructor(config?: Partial<LLMConfig>);
-    private detectProvider;
-    private getApiKey;
-    generate(prompt: string, options?: {
-        system?: string;
-        temperature?: number;
-        maxTokens?: number;
-        model?: string;
-    }): Promise<LLMResponse>;
-    private callAnthropic;
-}
-export default LLMClient;
+export interface LLMConfig {
+    provider: 'groq' | 'openai' | 'anthropic' | 'google' | 'nvidia' | 'custom';
+    apiKey: string;
+    baseUrl?: string;
+    model?: string;
+}
+export interface LLMResponse {
+    success: boolean;
+    text?: string;
+    error?: string;
+}
+export declare const CODEX_MODELS: {
+    readonly codex: "codex-2025-01-21";
+    readonly codexMini: "codex-mini";
+    readonly codexLatest: "codex-latest";
+};
+export declare const GPT_MODELS: {
+    readonly gpt4o: "gpt-4o";
+    readonly gpt4oMini: "gpt-4o-mini";
+    readonly gpt4Turbo: "gpt-4-turbo";
+    readonly o1: "o1";
+    readonly o3Mini: "o3-mini";
+};
+export declare class LLMClient {
+    private config;
+    constructor(config?: Partial<LLMConfig>);
+    private detectProvider;
+    private getApiKey;
+    generate(prompt: string, options?: {
+        system?: string;
+        temperature?: number;
+        maxTokens?: number;
+        model?: string;
+    }): Promise<LLMResponse>;
+}
+export default LLMClient;

package/dist/llm.js

@@ -1,129 +1,99 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMClient = void 0;
-const axios_1 = __importDefault(require("axios"));
-const PROVIDER_CONFIGS = {
-    groq: {
-        baseUrl: 'https://api.groq.com/openai/v1',
-        defaultModel: 'llama-3.3-70b-versatile',
-        apiFormat: 'openai'
-    },
-    openai: {
-        baseUrl: 'https://api.openai.com/v1',
-        defaultModel: 'gpt-4o-mini',
-        apiFormat: 'openai'
-    },
-    anthropic: {
-        baseUrl: 'https://api.anthropic.com',
-        defaultModel: 'claude-3-sonnet-20240229',
-        apiFormat: 'anthropic'
-    },
-    google: {
-        baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
-        defaultModel: 'gemini-1.5-flash',
-        apiFormat: 'openai'
-    },
-    nvidia: {
-        baseUrl: 'https://integrate.api.nvidia.com/v1',
-        defaultModel: 'meta/llama-3.1-405b-instruct',
-        apiFormat: 'openai'
-    }
-};
-class LLMClient {
-    constructor(config) {
-        // Auto-detect from environment
-        const provider = config?.provider || this.detectProvider();
-        const apiKey = config?.apiKey || this.getApiKey(provider);
-        if (!apiKey) {
-            throw new Error(`No API key found for LLM provider '${provider}'. Set ${provider.toUpperCase()}_API_KEY or GROQ_API_KEY`);
-        }
-        const preset = PROVIDER_CONFIGS[provider];
-        this.config = {
-            provider,
-            apiKey,
-            baseUrl: config?.baseUrl || preset?.baseUrl,
-            model: config?.model || preset?.defaultModel
-        };
-        this.client = axios_1.default.create({
-            baseURL: this.config.baseUrl,
-            headers: provider === 'anthropic'
-                ? { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' }
-                : { 'Authorization': `Bearer ${apiKey}` }
-        });
-    }
-    detectProvider() {
-        if (process.env.ANTHROPIC_API_KEY)
-            return 'anthropic';
-        if (process.env.OPENAI_API_KEY)
-            return 'openai';
-        if (process.env.GOOGLE_API_KEY)
-            return 'google';
-        if (process.env.NVIDIA_API_KEY)
-            return 'nvidia';
-        return 'groq'; // Default
-    }
-    getApiKey(provider) {
-        const envMap = {
-            groq: 'GROQ_API_KEY',
-            openai: 'OPENAI_API_KEY',
-            anthropic: 'ANTHROPIC_API_KEY',
-            google: 'GOOGLE_API_KEY',
-            nvidia: 'NVIDIA_API_KEY'
-        };
-        return process.env[envMap[provider]] || process.env.GROQ_API_KEY || process.env.RENTABOTS_LLM_KEY;
-    }
-    async generate(prompt, options = {}) {
-        const model = options.model || this.config.model;
-        try {
-            if (this.config.provider === 'anthropic') {
-                return await this.callAnthropic(prompt, options, model);
-            }
-            // OpenAI-compatible format
-            const res = await this.client.post('/chat/completions', {
-                model,
-                messages: [
-                    ...(options.system ? [{ role: 'system', content: options.system }] : []),
-                    { role: 'user', content: prompt }
-                ],
-                temperature: options.temperature ?? 0.7,
-                max_tokens: options.maxTokens ?? 2048
-            });
-            return {
-                success: true,
-                text: res.data.choices[0]?.message?.content,
-                usage: res.data.usage ? {
-                    promptTokens: res.data.usage.prompt_tokens,
-                    completionTokens: res.data.usage.completion_tokens
-                } : undefined
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.response?.data?.error?.message || error.message
-            };
-        }
-    }
-    async callAnthropic(prompt, options, model) {
-        const res = await this.client.post('/v1/messages', {
-            model,
-            messages: [{ role: 'user', content: prompt }],
-            system: options.system,
-            temperature: options.temperature ?? 0.7,
-            max_tokens: options.maxTokens ?? 2048
-        });
-        return {
-            success: true,
-            text: res.data.content[0]?.text,
-            usage: {
-                promptTokens: res.data.usage?.input_tokens || 0,
-                completionTokens: res.data.usage?.output_tokens || 0
-            }
-        };
-    }
-}
-exports.LLMClient = LLMClient;
-exports.default = LLMClient;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMClient = exports.GPT_MODELS = exports.CODEX_MODELS = void 0;
+const axios_1 = __importDefault(require("axios"));
+const CONFIGS = {
+    groq: { baseUrl: 'https://api.groq.com/openai/v1', defaultModel: 'llama-3.3-70b-versatile' },
+    openai: { baseUrl: 'https://api.openai.com/v1', defaultModel: 'gpt-4o' },
+    anthropic: { baseUrl: 'https://api.anthropic.com', defaultModel: 'claude-3-sonnet-20240229' },
+    google: { baseUrl: 'https://generativelanguage.googleapis.com/v1beta', defaultModel: 'gemini-1.5-flash' },
+    nvidia: { baseUrl: 'https://integrate.api.nvidia.com/v1', defaultModel: 'meta/llama-3.1-405b-instruct' },
+    custom: { baseUrl: '', defaultModel: '' }
+};
+// Codex models available via OpenAI API
+exports.CODEX_MODELS = {
+    codex: 'codex-2025-01-21', // Latest Codex
+    codexMini: 'codex-mini', // Mini version
+    codexLatest: 'codex-latest', // Alias to latest
+};
+// OpenAI GPT models
+exports.GPT_MODELS = {
+    gpt4o: 'gpt-4o',
+    gpt4oMini: 'gpt-4o-mini',
+    gpt4Turbo: 'gpt-4-turbo',
+    o1: 'o1',
+    o3Mini: 'o3-mini',
+};
+class LLMClient {
+    constructor(config) {
+        const provider = config?.provider || this.detectProvider();
+        const apiKey = config?.apiKey || this.getApiKey(provider);
+        if (!apiKey)
+            throw new Error(`No API key for ${provider}`);
+        const preset = CONFIGS[provider];
+        this.config = {
+            provider,
+            apiKey,
+            baseUrl: config?.baseUrl || preset.baseUrl,
+            model: config?.model || preset.defaultModel
+        };
+    }
+    detectProvider() {
+        if (process.env.ANTHROPIC_API_KEY)
+            return 'anthropic';
+        if (process.env.OPENAI_API_KEY)
+            return 'openai';
+        if (process.env.GOOGLE_API_KEY)
+            return 'google';
+        if (process.env.NVIDIA_API_KEY)
+            return 'nvidia';
+        return 'groq';
+    }
+    getApiKey(provider) {
+        const map = {
+            groq: 'GROQ_API_KEY',
+            openai: 'OPENAI_API_KEY',
+            anthropic: 'ANTHROPIC_API_KEY',
+            google: 'GOOGLE_API_KEY',
+            nvidia: 'NVIDIA_API_KEY',
+            custom: 'LLM_API_KEY'
+        };
+        return process.env[map[provider]];
+    }
+    async generate(prompt, options = {}) {
+        const model = options.model || this.config.model;
+        const headers = this.config.provider === 'anthropic'
+            ? { 'x-api-key': this.config.apiKey, 'anthropic-version': '2023-06-01' }
+            : { 'Authorization': `Bearer ${this.config.apiKey}` };
+        try {
+            if (this.config.provider === 'anthropic') {
+                const res = await axios_1.default.post(`${this.config.baseUrl}/v1/messages`, {
+                    model,
+                    messages: [{ role: 'user', content: prompt }],
+                    system: options.system,
+                    temperature: options.temperature ?? 0.7,
+                    max_tokens: options.maxTokens ?? 2048,
+                }, { headers });
+                return { success: true, text: res.data.content[0]?.text };
+            }
+            const res = await axios_1.default.post(`${this.config.baseUrl}/chat/completions`, {
+                model,
+                messages: [
+                    ...(options.system ? [{ role: 'system', content: options.system }] : []),
+                    { role: 'user', content: prompt }
+                ],
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.maxTokens ?? 2048,
+            }, { headers });
+            return { success: true, text: res.data.choices[0]?.message?.content };
+        }
+        catch (e) {
+            return { success: false, error: e.response?.data?.error?.message || e.message };
+        }
+    }
+}
+exports.LLMClient = LLMClient;
+exports.default = LLMClient;

package/dist/queen_brain.d.ts

@@ -11,6 +11,17 @@
  */
 import { Agent, Job, Message } from './index';
 export type QueenPhase = 'REQUIREMENTS_GATHERING' | 'REQUIREMENTS_CONFIRMED' | 'WORK_IN_PROGRESS' | 'QA_REVIEW' | 'COMPLETED';
+export interface VerificationGateState {
+    builderCompleted: boolean;
+    qaCompleted: boolean;
+    deliverablesVerified: boolean;
+    testsVerified: boolean;
+    testsStatus: 'passed' | 'failed' | 'no-tests-policy' | 'not-run';
+    repoDeliverableCount: number;
+    checklistSummary?: string;
+    verifiedAt?: string;
+    lastError?: string;
+}
 export interface QueenState {
     phase: QueenPhase;
     requirements: string[];
@@ -18,6 +29,7 @@ export interface QueenState {
     brainLog: string[];
     questionCount: number;
     lastHumanMessage: string;
+    verificationGate?: VerificationGateState;
 }
 export declare class QueenBrain {
     private agent;
@@ -59,6 +71,15 @@ export declare class QueenBrain {
      * Get the internal brain log for debugging
      */
     getBrainLog(jobId: string): string[];
+    private createDefaultGateState;
+    private ensureGate;
+    markWorkerCompleted(jobId: string, phase: 'BUILDER' | 'QA'): void;
+    updateVerificationGate(jobId: string, update: Partial<VerificationGateState>): void;
+    canHandover(jobId: string): {
+        allowed: boolean;
+        reasons: string[];
+        gate: VerificationGateState;
+    };
     private saveStates;
     private loadStates;
 }

package/dist/queen_brain.js

@@ -100,6 +100,7 @@ class QueenBrain {
             brainLog: [`[${new Date().toISOString()}] Mission assigned: ${job.title}`],
             questionCount: 0,
             lastHumanMessage: '',
+            verificationGate: this.createDefaultGateState(),
         };
         this.states.set(job.id, state);
         this.saveStates();
@@ -131,6 +132,7 @@ class QueenBrain {
                 brainLog: [],
                 questionCount: 0,
                 lastHumanMessage: '',
+                verificationGate: this.createDefaultGateState(),
             };
             this.states.set(msg.jobId, state);
         }
@@ -254,6 +256,61 @@ class QueenBrain {
     getBrainLog(jobId) {
         return this.states.get(jobId)?.brainLog || [];
     }
+    createDefaultGateState() {
+        return {
+            builderCompleted: false,
+            qaCompleted: false,
+            deliverablesVerified: false,
+            testsVerified: false,
+            testsStatus: 'not-run',
+            repoDeliverableCount: 0,
+        };
+    }
+    ensureGate(jobId) {
+        const state = this.states.get(jobId);
+        if (!state)
+            return this.createDefaultGateState();
+        if (!state.verificationGate) {
+            state.verificationGate = this.createDefaultGateState();
+        }
+        return state.verificationGate;
+    }
+    markWorkerCompleted(jobId, phase) {
+        const state = this.states.get(jobId);
+        if (!state)
+            return;
+        const gate = this.ensureGate(jobId);
+        if (phase === 'BUILDER')
+            gate.builderCompleted = true;
+        if (phase === 'QA')
+            gate.qaCompleted = true;
+        state.brainLog.push(`[${new Date().toISOString()}] QUEEN THOUGHT: Worker phase completed -> ${phase}`);
+        this.saveStates();
+    }
+    updateVerificationGate(jobId, update) {
+        const state = this.states.get(jobId);
+        if (!state)
+            return;
+        const gate = this.ensureGate(jobId);
+        state.verificationGate = { ...gate, ...update };
+        if (update.checklistSummary) {
+            state.brainLog.push(`[${new Date().toISOString()}] QUEEN CHECKLIST: ${update.checklistSummary}`);
+        }
+        this.saveStates();
+    }
+    canHandover(jobId) {
+        const gate = this.ensureGate(jobId);
+        const reasons = [];
+        if (!gate.builderCompleted)
+            reasons.push('Builder phase not completed');
+        if (!gate.qaCompleted)
+            reasons.push('QA phase not completed');
+        if (!gate.deliverablesVerified || gate.repoDeliverableCount <= 0)
+            reasons.push('Repo-backed deliverables not verified');
+        if (!gate.testsVerified)
+            reasons.push(`Test/check gate not passed (status: ${gate.testsStatus})`);
+        return { allowed: reasons.length === 0, reasons, gate };
+    }
     // --- PERSISTENCE ---
     saveStates() {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rentabots-sdk",
-  "version": "1.7.1",
+  "version": "1.7.7",
   "description": "Official SDK for RentaBots AI Agent Marketplace",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,4 +40,4 @@
   },
   "author": "",
   "license": "ISC"
-}
+}