rentabots-sdk 1.7.0 → 1.7.6

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;
@@ -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,94 +125,89 @@ 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;
+        files?: any[];
+        issues?: string[];
+        error?: string;
+    }>;
+    preDeliveryCheck(jobId: string): Promise<{
+        canDeliver: boolean;
+        checks: any[];
+        recommendations?: string[];
+    }>;
     markComplete(jobId: string): Promise<any>;
-    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<import("axios").AxiosResponse<any, any, {}> | undefined>;
-    /**
-     * 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;
+    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;
-        bidsPlaced: number;
-        error?: undefined;
-    } | {
+        text?: string;
+        error?: string;
+    }>;
+    askLLM(systemPrompt: string, userPrompt: string): Promise<string | null>;
+    analyzeRequirements(job: Job): Promise<{
         success: boolean;
-        error: any;
-        bidsPlaced?: undefined;
+        requirements?: any;
+        error?: string;
     }>;
-    /**
-     * 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<any>;
-    /**
-     * Upload files to a mission's repository
-     */
-    uploadToRepo(jobId: string, files: {
-        path: string;
-        content: string;
-    }[]): Promise<({
-        path: string;
+    codeGenerator(prompt: string, language?: string): Promise<{
         success: boolean;
-        error?: undefined;
-    } | {
-        path: string;
+        code?: string;
+        error?: string;
+    }>;
+    reviewCode(code: string, requirements: string): Promise<{
         success: boolean;
-        error: any;
-    })[]>;
-    /**
-     * Check if a repository exists for a mission and get its info
-     */
-    getRepo(jobId: string): Promise<any>;
-    /**
-     * 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;
+        review?: string;
+        passed: boolean;
+        error?: string;
+    }>;
+    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>;
     private enrichJob;
     private syncFromCloud;
     private loadState;

package/dist/index.js

@@ -38,6 +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"));
+const llm_1 = require("./llm");
 const socket_io_client_1 = require("socket.io-client");
 const zod_1 = require("zod");
 const events_1 = require("events");
@@ -45,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({
@@ -86,7 +71,7 @@ exports.MessageSchema = zod_1.z.object({
     })
 });
 // --- CORE SDK ENGINE ---
-let SDK_VERSION = '1.5.7'; // BUMP to v1.5.7
+let SDK_VERSION = '1.7.6'; // BUMP to v1.5.7
 try {
     const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
     SDK_VERSION = pkg.version;
@@ -115,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.
@@ -371,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 ---
@@ -463,294 +412,242 @@ class Agent extends events_1.EventEmitter {
             return { success: false, error: e.response?.data?.error || e.message };
         }
     }
-    async deliver(jobId, files) {
-        const cwd = path.join(this.workspaceRoot, jobId);
-        for (const file of files) {
-            const local = path.join(cwd, file);
-            if (fs.existsSync(local)) {
-                const content = fs.readFileSync(local, 'utf8');
-                await this.api.post(`jobs/${jobId}/repo/files`, { path: file, content });
-            }
-        }
-    }
-    async markComplete(jobId) {
-        const res = await this.api.post(`jobs/${jobId}/complete`, { userId: this.agentId, role: 'agent' });
-        if (res.data.success) {
-            const job = this.activeMissions.get(jobId);
-            if (job)
-                this.completedMissions.set(jobId, { ...job, status: 'completed' });
-            this.activeMissions.delete(jobId);
-            this.saveState();
-        }
-        return res.data;
-    }
-    async bid(jobId, amount, message) {
+    // --- 📊 PROGRESS TRACKING ---
+    async setProgress(jobId, percent) {
         try {
-            const res = await this.api.post('bids', { jobId, amount, message });
-            if (res.data.success) {
-                this.bidCache.add(jobId);
-                // 📡 JOIN ROOM IMMEDIATELY: Allows chatting before assignment
-                this.socket?.emit('join_mission', jobId);
-                this.logInternal(`Joined telemetry room for pending bid: ${jobId}`);
+            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 res.data;
+            return { success: true };
         }
         catch (e) {
-            return { success: false };
+            return { success: false, error: e.response?.data?.error || e.message };
         }
     }
-    async sendMessage(jobId, content) {
-        return this.api.post(`jobs/${jobId}/messages`, { content, senderId: this.agentId });
-    }
-    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) {
+    // --- 📦 REPO MANAGEMENT ---
+    async createRepo(jobId, name) {
         try {
-            return await this.api.post(`jobs/${jobId}/progress`, { progress, agentId: this.agentId });
+            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) {
-            this.logInternal(`Failed to update progress for ${jobId}: ${e.message}`);
+            return { success: false, error: e.response?.data?.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 = {}) {
+    async getRepo(jobId) {
         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 };
+            const res = await this.api.get(`jobs/${jobId}/repo`);
+            return { success: true, exists: res.data.exists, repo: res.data.repo };
         }
         catch (e) {
-            this.logInternal(`findAndBid failed: ${e.message}`);
-            return { success: false, error: e.message };
+            if (e.response?.status === 404)
+                return { success: true, exists: false };
+            return { success: false, exists: false, error: e.response?.data?.error || e.message };
         }
     }
-    /**
-     * Notify the agent's human owner (via API)
-     */
-    async notifyOwner(message) {
+    async uploadRepoFile(jobId, filePath, content, isBlob = false) {
         try {
-            return await this.api.post('agents/me/notify', { message });
+            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) {
-            this.logInternal(`notifyOwner failed: ${e.message}`);
+            return { success: false, error: e.response?.data?.error || e.message };
         }
     }
-    /**
-     * Log a message to the agent's server-side log
-     */
-    async log(message, level = 'INFO') {
-        this.logInternal(`[${level}] ${message}`);
+    async downloadRepoFile(jobId, filePath) {
         try {
-            return await this.api.post('agents/me/logs', { message, level });
+            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) {
-            // Swallow — logging should never crash the agent
+            return { success: false, error: e.response?.data?.error || e.message };
         }
     }
-    /**
-     * Alias: triggered when human hires this agent
-     */
-    onHired(callback) {
-        this.on('assignment', callback);
+    isBinaryFile(filePath) {
+        const textExts = ['.js', '.ts', '.json', '.md', '.txt', '.html', '.css', '.yml', '.yaml', '.toml'];
+        return !textExts.includes(path.extname(filePath).toLowerCase());
     }
-    /**
-     * Alias: triggered on incoming chat message
-     */
-    onMessage(callback) {
-        this.on('message', callback);
+    async deliver(jobId, files) {
+        const cwd = path.join(this.workspaceRoot, jobId);
+        for (const file of files) {
+            const local = path.join(cwd, file);
+            if (fs.existsSync(local)) {
+                const content = fs.readFileSync(local, 'utf8');
+                await this.api.post(`jobs/${jobId}/repo/files`, { path: file, content });
+            }
+        }
     }
-    /**
-     * Upload a deliverable file to a mission
-     */
-    async uploadDeliverable(jobId, url, name) {
+    // --- ✅ VERIFICATION FLOW ---
+    // --- 🧪 TEST RUNNER ---
+    async runTests(jobId, command = 'npm test') {
         try {
-            return await this.api.post(`jobs/${jobId}/files`, {
-                url,
-                name,
-                type: 'deliverable',
-                userId: this.agentId
-            });
+            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) {
-            this.logInternal(`uploadDeliverable failed: ${e.message}`);
+            return { success: false, passed: false, error: e.message };
         }
     }
-    /**
-     * Create a private repository for a mission
-     */
-    async createRepo(jobId, name) {
+    async verifyDeliverables(jobId) {
         try {
-            const res = await this.api.post(`jobs/${jobId}/repo`, { name });
-            this.logInternal(`Repository created for job ${jobId}`);
-            return res.data;
+            const cwd = path.join(this.workspaceRoot, jobId);
+            if (!fs.existsSync(cwd))
+                return { success: false, verified: false, error: 'No workspace' };
+            const issues = [];
+            const files = [];
+            const scanDir = (dir, rel = '') => {
+                fs.readdirSync(dir).forEach((item) => {
+                    const full = path.join(dir, item);
+                    const relPath = path.join(rel, item);
+                    if (fs.statSync(full).isDirectory())
+                        scanDir(full, relPath);
+                    else
+                        files.push({ path: relPath, size: fs.statSync(full).size });
+                });
+            };
+            scanDir(cwd);
+            if (files.length === 0)
+                issues.push('No deliverables');
+            if (!files.some(f => f.path.toLowerCase().includes('readme')))
+                issues.push('Missing README');
+            const verified = issues.length === 0;
+            return { success: true, verified, files, issues };
         }
         catch (e) {
-            this.logInternal(`createRepo failed: ${e.message}`);
-            return { success: false, error: e.message };
+            return { success: false, verified: false, error: e.message };
+        }
+    }
+    async preDeliveryCheck(jobId) {
+        const verify = await this.verifyDeliverables(jobId);
+        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);
+        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' });
+        if (res.data.success) {
+            const job = this.activeMissions.get(jobId);
+            if (job)
+                this.completedMissions.set(jobId, { ...job, status: 'completed' });
+            this.activeMissions.delete(jobId);
+            this.saveState();
         }
+        return res.data;
     }
-    /**
-     * Upload files to a mission's repository
-     */
-    async uploadToRepo(jobId, files) {
-        const results = [];
-        for (const file of files) {
+    async initLLM(config) {
+        this.llmClient = new llm_1.LLMClient(config);
+    }
+    async generate(prompt, options = {}) {
+        if (!this.llmClient) {
             try {
-                const res = await this.api.post(`jobs/${jobId}/repo/files`, file);
-                results.push({ path: file.path, success: true });
+                this.llmClient = new llm_1.LLMClient();
             }
             catch (e) {
-                results.push({ path: file.path, success: false, error: e.message });
+                return { success: false, error: e.message };
             }
         }
-        return results;
+        return this.llmClient.generate(prompt, options);
     }
-    /**
-     * Check if a repository exists for a mission and get its info
-     */
-    async getRepo(jobId) {
+    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', temperature: 0.3 });
+        if (!res.success)
+            return res;
         try {
-            const res = await this.api.get(`jobs/${jobId}/repo`);
-            return res.data;
+            const json = res.text?.match(/\{[^]*\}/)?.[0];
+            return { success: true, requirements: JSON.parse(json || '{}') };
         }
-        catch (e) {
-            return { exists: false };
+        catch {
+            return { success: false, error: 'Parse failed' };
         }
     }
-    // --- 🧠 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);
-        }
+    async codeGenerator(prompt, language = 'javascript') {
+        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() };
     }
-    /**
-     * 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));
-        });
+    async reviewCode(code, requirements) {
+        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'));
+        return { success: true, review: res.text, passed };
     }
-    /**
-     * 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;
-        }
+    async bid(jobId, amount, message) {
         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;
+            const res = await this.api.post('bids', { jobId, amount, message });
+            if (res.data.success) {
+                this.bidCache.add(jobId);
+                // 📡 JOIN ROOM IMMEDIATELY: Allows chatting before assignment
+                this.socket?.emit('join_mission', jobId);
+                this.logInternal(`Joined telemetry room for pending bid: ${jobId}`);
+                this.saveState();
             }
+            return res.data;
         }
         catch (e) {
-            this.logInternal(`LLM call failed (${provider}): ${e.message}`);
-            return null;
+            return { success: false };
         }
     }
+    async sendMessage(jobId, content) {
+        return this.api.post(`jobs/${jobId}/messages`, { content, senderId: this.agentId });
+    }
+    async setTyping(jobId, isTyping = true) {
+        this.socket?.emit('typing_state', { jobId, isTyping });
+    }
     // --- UTILS ---
     enrichJob(raw) {
         return {

package/dist/llm.d.ts

@@ -0,0 +1,24 @@
+export interface LLMConfig {
+    provider: 'groq' | 'openai' | 'anthropic' | 'google' | 'nvidia';
+    apiKey: string;
+    baseUrl?: string;
+    model?: string;
+}
+export interface LLMResponse {
+    success: boolean;
+    text?: string;
+    error?: string;
+}
+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

@@ -0,0 +1,70 @@
+"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 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-mini' },
+    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' },
+};
+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: preset.baseUrl, 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',
+        };
+        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/package.json

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