rentabots-sdk 1.6.0 → 1.6.4

package/dist/index.d.ts

@@ -125,8 +125,72 @@ 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;
+    }>;
+    private isBinaryFile;
     deliver(jobId: string, files: string[]): Promise<void>;
+    verifyDeliverables(jobId: string): Promise<{
+        success: boolean;
+        verified: boolean;
+        files?: any[];
+        issues?: string[];
+        error?: string;
+    }>;
+    preDeliveryCheck(jobId: string): Promise<{
+        canDeliver: boolean;
+        checks: any[];
+    }>;
     markComplete(jobId: string): Promise<any>;
+    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;
+    }>;
+    analyzeRequirements(job: Job): Promise<{
+        success: boolean;
+        requirements?: any;
+        error?: string;
+    }>;
+    codeGenerator(prompt: string, language?: string): Promise<{
+        success: boolean;
+        code?: string;
+        error?: string;
+    }>;
+    reviewCode(code: string, requirements: string): Promise<{
+        success: boolean;
+        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>;

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");
@@ -70,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.6.2'; // BUMP to v1.5.7
 try {
     const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
     SDK_VERSION = pkg.version;
@@ -411,6 +412,66 @@ 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 };
+        }
+    }
+    isBinaryFile(filePath) {
+        const textExts = ['.js', '.ts', '.json', '.md', '.txt', '.html', '.css', '.yml', '.yaml', '.toml'];
+        return !textExts.includes(path.extname(filePath).toLowerCase());
+    }
     async deliver(jobId, files) {
         const cwd = path.join(this.workspaceRoot, jobId);
         for (const file of files) {
@@ -421,6 +482,43 @@ class Agent extends events_1.EventEmitter {
             }
         }
     }
+    // --- ✅ VERIFICATION FLOW ---
+    async verifyDeliverables(jobId) {
+        try {
+            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) {
+            return { success: false, verified: false, error: e.message };
+        }
+    }
+    async preDeliveryCheck(jobId) {
+        const verify = await this.verifyDeliverables(jobId);
+        const checks = [{ name: 'Deliverables', passed: verify.verified, details: verify.files?.length + ' files' }];
+        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 };
+    }
     async markComplete(jobId) {
         const res = await this.api.post(`jobs/${jobId}/complete`, { userId: this.agentId, role: 'agent' });
         if (res.data.success) {
@@ -432,6 +530,47 @@ class Agent extends events_1.EventEmitter {
         }
         return res.data;
     }
+    async initLLM(config) {
+        this.llmClient = new llm_1.LLMClient(config);
+    }
+    async generate(prompt, options = {}) {
+        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 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 json = res.text?.match(/\{[^]*\}/)?.[0];
+            return { success: true, requirements: JSON.parse(json || '{}') };
+        }
+        catch {
+            return { success: false, error: 'Parse failed' };
+        }
+    }
+    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() };
+    }
+    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 };
+    }
     async bid(jobId, amount, message) {
         try {
             const res = await this.api.post('bids', { jobId, amount, message });

package/dist/llm.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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;

package/dist/llm.js

@@ -0,0 +1,129 @@
+"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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rentabots-sdk",
-  "version": "1.6.0",
+  "version": "1.6.4",
   "description": "Official SDK for RentaBots AI Agent Marketplace",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",