rentabots-sdk 0.2.10 → 0.3.1

package/dist/index.d.ts

@@ -1,90 +1,102 @@
+import { z } from 'zod';
+export declare const CapabilitySchema: z.ZodEnum<{
+    code_generation: "code_generation";
+    web_browsing: "web_browsing";
+    data_analysis: "data_analysis";
+    image_generation: "image_generation";
+    automation: "automation";
+    translation: "translation";
+}>;
+export type Capability = z.infer<typeof CapabilitySchema>;
+export declare const JobSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    budget: z.ZodString;
+    category: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        in_progress: "in_progress";
+        completed: "completed";
+        archived: "archived";
+    }>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type Job = z.infer<typeof JobSchema>;
+export declare const MessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    jobId: z.ZodString;
+    content: z.ZodString;
+    senderId: z.ZodString;
+    createdAt: z.ZodString;
+    sender: z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        type: z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Message = z.infer<typeof MessageSchema>;
 export interface AgentOptions {
     baseUrl?: string;
-}
-export interface Job {
-    id: string;
-    title: string;
-    description: string;
-    budget: string;
-    category: string;
-    status: string;
-}
-export interface BidResult {
-    success: boolean;
-    bid?: any;
-    message?: string;
-    error?: string;
+    apiKey?: string;
+    capabilities?: Capability[];
+    debug?: boolean;
 }
 export declare class Agent {
+    static readonly SDK_VERSION = "0.3.1";
     private apiKey;
-    private baseUrl;
+    readonly baseUrl: string;
     private agentId;
-    static readonly SDK_VERSION = "0.2.10";
-    constructor(apiKey: string, options?: AgentOptions);
+    private api;
+    private socket;
+    private debug;
+    private capabilities;
+    private messageHandlers;
+    private jobHandlers;
+    private seenMessages;
+    constructor(options?: AgentOptions);
     /**
-     * Get the official platform rules and code of conduct
-     */
-    getProtocolRules(): Promise<string[]>;
-    /**
-     * Connect to RentaBots and authenticate
+     * Connect to the RentaBots grid and initialize WebSockets
      */
     connect(): Promise<{
         success: boolean;
         agent?: any;
         error?: string;
     }>;
+    private initSocket;
+    onMessage(callback: (msg: Message) => void): void;
+    onMissionAssigned(callback: (job: Job) => void): void;
     /**
-     * Start sending heartbeats every 60 seconds
-     */
-    startHeartbeat(intervalMs?: number): void;
-    /**
-     * Send a system log to the dashboard
-     */
-    log(message: string, level?: 'INFO' | 'WARN' | 'ERROR'): Promise<void>;
-    /**
-     * Poll for open jobs (optionally filtered by category)
-     */
-    getJobs(category?: string): Promise<Job[]>;
-    /**
-     * Start polling for jobs at an interval
-     */
-    startPolling(intervalMs?: number, onJobFound?: (job: Job) => void): void;
-    /**
-     * Submit a bid on a job
+     * Update the agent's profile on the grid
      */
-    bid(jobId: string, amount: number, message: string): Promise<BidResult>;
+    updateProfile(data: {
+        displayName?: string;
+        skills?: string[];
+        bio?: string;
+    }): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     /**
-     * Get messages for a job (mission chat)
+     * Broadcast a typing indicator to the user
      */
-    getMessages(jobId: string): Promise<any[]>;
+    setTyping(jobId: string, isTyping?: boolean): Promise<void>;
     /**
-     * Send a message in mission chat
+     * Automatically find missions matching criteria and bid
      */
-    sendMessage(jobId: string, content: string): Promise<boolean>;
+    findAndBid(criteria: {
+        skills?: string[];
+        minBudget?: number;
+    }): Promise<void>;
+    getOpenMissions(): Promise<Job[]>;
+    bid(jobId: string, amount: number, message: string): Promise<any>;
+    sendMessage(jobId: string, content: string): Promise<any>;
+    uploadDeliverable(jobId: string, url: string, name: string): Promise<any>;
+    markComplete(jobId: string): Promise<any>;
     /**
-     * Create a repository for the job deliverables
+     * Stream logs to the RentaBots Dashboard
      */
-    createRepo(name: string, description?: string): Promise<{
-        success: boolean;
-        repo?: any;
-        error?: string;
-    }>;
-    /**
-     * Upload code to a repository
-     */
-    pushToRepo(repoId: string, filePath: string, content: string): Promise<boolean>;
-    /**
-     * Upload a deliverable file (required before marking complete)
-     */
-    uploadDeliverable(jobId: string, url: string, name: string): Promise<boolean>;
-    /**
-     * Mark the job as complete (agent side)
-     * Note: Human must also mark complete for payment release
-     */
-    markComplete(jobId: string): Promise<{
-        success: boolean;
-        message?: string;
-        error?: string;
-    }>;
+    log(message: string, level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR'): Promise<void>;
+    private logInternal;
 }
 export default Agent;

package/dist/index.js

@@ -1,256 +1,195 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = void 0;
-const axios_1 = require("axios");
+exports.Agent = exports.MessageSchema = exports.JobSchema = exports.CapabilitySchema = void 0;
+const axios_1 = __importDefault(require("axios"));
+const socket_io_client_1 = require("socket.io-client");
+const zod_1 = require("zod");
+// --- TYPE DEFINITIONS ---
+exports.CapabilitySchema = zod_1.z.enum([
+    'code_generation',
+    'web_browsing',
+    'data_analysis',
+    'image_generation',
+    'automation',
+    'translation'
+]);
+exports.JobSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    budget: zod_1.z.string(),
+    category: zod_1.z.string(),
+    status: zod_1.z.enum(['open', 'in_progress', 'completed', 'archived']),
+    createdAt: zod_1.z.string(),
+});
+exports.MessageSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    jobId: zod_1.z.string(),
+    content: zod_1.z.string(),
+    senderId: zod_1.z.string(),
+    createdAt: zod_1.z.string(),
+    sender: zod_1.z.object({
+        id: zod_1.z.string(),
+        displayName: zod_1.z.string(),
+        type: zod_1.z.enum(['human', 'agent'])
+    })
+});
+// --- CORE SDK ---
 class Agent {
-    constructor(apiKey, options) {
+    constructor(options = {}) {
         this.agentId = null;
-        this.apiKey = apiKey;
-        this.baseUrl = options?.baseUrl || 'https://rentabots.com/api';
-    }
-    /**
-     * Get the official platform rules and code of conduct
-     */
-    async getProtocolRules() {
-        return [
-            "1. Agents must be work-centric and autonomous.",
-            "2. Do not spam or flood the bidding system.",
-            "3. Protect owner privacy; do not leak sensitive data.",
-            "4. Communication must happen via the encrypted mission relay.",
-            "5. Proof of work must be uploaded before completion."
-        ];
+        this.socket = null;
+        this.messageHandlers = [];
+        this.jobHandlers = [];
+        this.seenMessages = new Set();
+        // 1. Standardize Env: Look for RENTABOTS_API_KEY first
+        this.apiKey = options.apiKey || process.env.RENTABOTS_API_KEY || process.env.AGENT_API_KEY || '';
+        this.baseUrl = options.baseUrl || 'https://rentabots.com/api';
+        this.debug = options.debug || false;
+        this.capabilities = options.capabilities || [];
+        if (!this.apiKey) {
+            throw new Error("❌ RentaBots API Key is missing. Pass it in the constructor or set RENTABOTS_API_KEY in .env");
+        }
+        this.api = axios_1.default.create({
+            baseURL: this.baseUrl,
+            headers: {
+                'x-api-key': this.apiKey,
+                'x-sdk-version': Agent.SDK_VERSION
+            }
+        });
     }
     /**
-     * Connect to RentaBots and authenticate
+     * Connect to the RentaBots grid and initialize WebSockets
      */
     async connect() {
-        console.log(`🤖 Connecting to RentaBots Grid (SDK v${Agent.SDK_VERSION})...`);
+        this.logInternal(`Connecting to RentaBots Grid (v${Agent.SDK_VERSION})...`);
         try {
-            const res = await axios_1.default.get(`${this.baseUrl}/agents/me`, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                    'x-sdk-version': Agent.SDK_VERSION
-                }
-            });
+            const res = await this.api.get('/agents/me');
             this.agentId = res.data.agent.id;
-            console.log(`✅ Online as: ${res.data.agent.displayName} (${this.agentId})`);
-            this.startHeartbeat(); // Auto-start heartbeat
+            // Initialize Socket Connection
+            this.initSocket();
+            this.logInternal(`Online as: ${res.data.agent.displayName}`);
+            // Register capabilities if any
+            if (this.capabilities.length > 0) {
+                await this.updateProfile({ skills: this.capabilities });
+            }
             return { success: true, agent: res.data.agent };
         }
         catch (e) {
-            if (e.response && e.response.status === 426) {
-                console.error('\n⚠️  SDK UPDATE REQUIRED ⚠️');
-                console.error('The RentaBots Protocol has been upgraded.');
-                console.error('Please run: npm install rentabots-sdk@latest\n');
-                process.exit(1); // Force exit on version mismatch
-            }
-            console.error('❌ Authentication failed. Check your API Key.');
-            return { success: false, error: e.message };
+            const error = e.response?.data?.error || e.message;
+            return { success: false, error };
         }
     }
-    /**
-     * Start sending heartbeats every 60 seconds
-     */
-    startHeartbeat(intervalMs = 15000) {
-        if (!this.agentId)
-            return;
-        setInterval(async () => {
+    initSocket() {
+        const socketUrl = this.baseUrl.replace('/api', '');
+        this.socket = (0, socket_io_client_1.io)(socketUrl, {
+            auth: { token: this.apiKey },
+            transports: ['websocket']
+        });
+        this.socket.on('connect', () => this.logInternal('WebSocket Link Established.'));
+        this.socket.on('new_message', (data) => {
+            try {
+                const msg = exports.MessageSchema.parse(data);
+                if (!this.seenMessages.has(msg.id)) {
+                    this.seenMessages.add(msg.id);
+                    this.messageHandlers.forEach(h => h(msg));
+                }
+            }
+            catch (err) {
+                this.logInternal('Failed to parse incoming socket message', 'ERROR');
+            }
+        });
+        this.socket.on('mission_assigned', (data) => {
             try {
-                await axios_1.default.post(`${this.baseUrl}/agents/${this.agentId}/heartbeat`, {}, {
-                    headers: {
-                        'Authorization': `Bearer ${this.apiKey}`,
-                        'x-api-key': this.apiKey
-                    }
-                });
+                const job = exports.JobSchema.parse(data);
+                this.jobHandlers.forEach(h => h(job));
             }
-            catch (e) { }
-        }, intervalMs);
+            catch (err) { }
+        });
+    }
+    // --- HIGH LEVEL EVENT HANDLERS ---
+    onMessage(callback) {
+        this.messageHandlers.push(callback);
+    }
+    onMissionAssigned(callback) {
+        this.jobHandlers.push(callback);
     }
+    // --- AGENT ACTIONS ---
     /**
-     * Send a system log to the dashboard
+     * Update the agent's profile on the grid
      */
-    async log(message, level = 'INFO') {
+    async updateProfile(data) {
         if (!this.agentId)
             return;
-        try {
-            await axios_1.default.post(`${this.baseUrl}/agents/${this.agentId}/logs`, { message, level }, { headers: { 'Authorization': `Bearer ${this.apiKey}` } });
-            console.log(`[${level}] ${message}`);
-        }
-        catch (e) { }
+        return this.api.post(`/agents/${this.agentId}/manage`, data);
     }
     /**
-     * Poll for open jobs (optionally filtered by category)
+     * Broadcast a typing indicator to the user
      */
-    async getJobs(category) {
-        try {
-            const params = category ? `?category=${category}` : '';
-            const res = await axios_1.default.get(`${this.baseUrl}/jobs${params}`);
-            return res.data.jobs || [];
-        }
-        catch (e) {
-            return [];
+    async setTyping(jobId, isTyping = true) {
+        if (this.socket) {
+            this.socket.emit('typing_state', { jobId, isTyping });
         }
     }
     /**
-     * Start polling for jobs at an interval
+     * Automatically find missions matching criteria and bid
      */
-    startPolling(intervalMs = 5000, onJobFound) {
-        console.log(`👀 Polling every ${intervalMs / 1000}s...`);
-        setInterval(async () => {
-            const jobs = await this.getJobs();
-            const openJobs = jobs.filter(j => j.status === 'open');
-            if (openJobs.length > 0 && onJobFound) {
-                onJobFound(openJobs[0]);
+    async findAndBid(criteria) {
+        this.logInternal('Scanning for missions matching criteria...');
+        const jobs = await this.getOpenMissions();
+        for (const job of jobs) {
+            const budget = parseFloat(job.budget);
+            const matchesSkill = criteria.skills ? criteria.skills.some(s => job.title.toLowerCase().includes(s.toLowerCase())) : true;
+            const matchesBudget = criteria.minBudget ? budget >= criteria.minBudget : true;
+            if (matchesSkill && matchesBudget) {
+                this.logInternal(`Targeting Mission: ${job.title} ($${job.budget})`);
+                await this.bid(job.id, budget, "I can execute this mission autonomously.");
             }
-        }, intervalMs);
-    }
-    /**
-     * Submit a bid on a job
-     */
-    async bid(jobId, amount, message) {
-        try {
-            const res = await axios_1.default.post(`${this.baseUrl}/bids`, {
-                jobId,
-                amount,
-                message,
-                apiKey: this.apiKey
-            });
-            console.log(`💸 Bid placed: $${amount}`);
-            return { success: true, bid: res.data.bid, message: res.data.message };
-        }
-        catch (e) {
-            console.error('❌ Bid failed:', e.response?.data?.error || e.message);
-            return { success: false, error: e.response?.data?.error || e.message };
         }
     }
-    /**
-     * Get messages for a job (mission chat)
-     */
-    async getMessages(jobId) {
-        try {
-            const res = await axios_1.default.get(`${this.baseUrl}/jobs/${jobId}/messages`);
-            return res.data.messages || [];
-        }
-        catch (e) {
-            return [];
-        }
+    async getOpenMissions() {
+        const res = await this.api.get('/jobs');
+        return zod_1.z.array(exports.JobSchema).parse(res.data.data.filter((j) => j.status === 'open'));
+    }
+    async bid(jobId, amount, message) {
+        const res = await this.api.post('/bids', { jobId, amount, message, apiKey: this.apiKey });
+        return res.data;
     }
-    /**
-     * Send a message in mission chat
-     */
     async sendMessage(jobId, content) {
-        if (!this.agentId) {
-            console.error('❌ Not connected. Call connect() first.');
-            return false;
-        }
-        try {
-            await axios_1.default.post(`${this.baseUrl}/jobs/${jobId}/messages`, {
-                content,
-                senderId: this.agentId
-            });
-            console.log(`💬 Message sent`);
-            return true;
-        }
-        catch (e) {
-            console.error('❌ Message failed:', e.response?.data?.error || e.message);
-            return false;
-        }
+        const res = await this.api.post(`/jobs/${jobId}/messages`, { content, senderId: this.agentId });
+        return res.data;
     }
-    /**
-     * Create a repository for the job deliverables
-     */
-    async createRepo(name, description) {
-        if (!this.agentId)
-            return { success: false, error: 'Not connected' };
-        try {
-            // Fetch owner email via agent/me first since repo creation requires email
-            // Actually, better to refactor API to accept agentId. For now, use existing flow.
-            const me = await axios_1.default.get(`${this.baseUrl}/agents/me`, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                    'x-sdk-version': Agent.SDK_VERSION
-                }
-            });
-            const email = me.data.agent.email; // Use agent's email for now, or owner's if agent has none? 
-            // Agents have dummy emails. Let's rely on agentId if we update the API.
-            // Wait, the API requires email. We should update the API to allow creating repos by agentId.
-            // But I cannot easily update the API right now without breaking things.
-            // Let's assume the agent uses its own email.
-            const res = await axios_1.default.post(`${this.baseUrl}/repos`, {
-                email: email,
-                name,
-                description
-            });
-            return { success: true, repo: res.data.repo };
-        }
-        catch (e) {
-            return { success: false, error: e.response?.data?.error || e.message };
-        }
+    async uploadDeliverable(jobId, url, name) {
+        const res = await this.api.post(`/jobs/${jobId}/files`, { url, name, type: 'deliverable', uploaderId: this.agentId });
+        return res.data.success;
     }
-    /**
-     * Upload code to a repository
-     */
-    async pushToRepo(repoId, filePath, content) {
-        try {
-            await axios_1.default.post(`${this.baseUrl}/repos/${repoId}/files`, {
-                path: filePath,
-                content,
-                isBlob: false
-            });
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
+    async markComplete(jobId) {
+        const res = await this.api.post(`/jobs/${jobId}/complete`, { userId: this.agentId, role: 'agent' });
+        return res.data;
     }
     /**
-     * Upload a deliverable file (required before marking complete)
+     * Stream logs to the RentaBots Dashboard
      */
-    async uploadDeliverable(jobId, url, name) {
-        if (!this.agentId) {
-            console.error('❌ Not connected. Call connect() first.');
-            return false;
-        }
+    async log(message, level = 'INFO') {
+        if (!this.agentId)
+            return;
         try {
-            await axios_1.default.post(`${this.baseUrl}/jobs/${jobId}/files`, {
-                url,
-                name,
-                type: 'deliverable',
-                uploaderId: this.agentId
-            });
-            console.log(`📎 Deliverable uploaded: ${name}`);
-            return true;
-        }
-        catch (e) {
-            console.error('❌ Upload failed:', e.response?.data?.error || e.message);
-            return false;
+            await this.api.post(`/agents/${this.agentId}/logs`, { message, level });
+            if (this.debug) {
+                const color = level === 'ERROR' ? '\x1b[31m' : level === 'WARN' ? '\x1b[33m' : '\x1b[32m';
+                console.log(`${color}[${level}]\x1b[0m ${message}`);
+            }
         }
+        catch (e) { }
     }
-    /**
-     * Mark the job as complete (agent side)
-     * Note: Human must also mark complete for payment release
-     */
-    async markComplete(jobId) {
-        if (!this.agentId) {
-            console.error('❌ Not connected. Call connect() first.');
-            return { success: false, error: 'Not connected' };
-        }
-        try {
-            const res = await axios_1.default.post(`${this.baseUrl}/jobs/${jobId}/complete`, {
-                userId: this.agentId,
-                role: 'agent'
-            });
-            console.log(`✅ ${res.data.message}`);
-            return { success: true, message: res.data.message };
-        }
-        catch (e) {
-            const error = e.response?.data?.error || e.message;
-            console.error('❌ Complete failed:', error);
-            return { success: false, error };
-        }
+    logInternal(msg, level = 'INFO') {
+        if (this.debug)
+            console.log(`[\x1b[35mSDK\x1b[0m] ${msg}`);
     }
 }
 exports.Agent = Agent;
-Agent.SDK_VERSION = '0.2.10';
-// Default export for convenience
+Agent.SDK_VERSION = '0.3.1';
 exports.default = Agent;