@ruvector/edge-net 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "Distributed compute intelligence network with AI agents and workers - contribute browser compute, spawn distributed AI agents, earn credits. Features Time Crystal coordination, Neural DAG attention, P2P swarm intelligence, and multi-agent workflows.",
   "main": "ruvector_edge_net.js",
@@ -62,6 +62,8 @@
     "webrtc.js",
     "agents.js",
     "real-agents.js",
+    "real-workers.js",
+    "real-workflows.js",
     "sync.js",
     "README.md",
     "LICENSE"
@@ -80,6 +82,12 @@
     "./real-agents": {
       "import": "./real-agents.js"
     },
+    "./real-workers": {
+      "import": "./real-workers.js"
+    },
+    "./real-workflows": {
+      "import": "./real-workflows.js"
+    },
     "./sync": {
       "import": "./sync.js"
     },

package/real-agents.js

@@ -2,7 +2,8 @@
  * @ruvector/edge-net REAL Agent System
  *
  * Actually functional distributed agents with:
- * - Real LLM API calls (Anthropic Claude, OpenAI)
+ * - LOCAL LLM execution via ruvllm (default - no API key needed)
+ * - Cloud LLM API calls (Anthropic Claude, OpenAI) as fallback
  * - Real embeddings via ruvector AdaptiveEmbedder
  * - Real relay server sync
  * - Real task execution
@@ -20,13 +21,34 @@ import { join } from 'path';
 // ============================================
 
 const LLM_PROVIDERS = {
+    // LOCAL LLM - Default, no API key needed
+    local: {
+        name: 'RuvLLM Local',
+        type: 'local',
+        models: {
+            fast: 'ruvllm-fast',
+            balanced: 'ruvllm-balanced',
+            powerful: 'ruvllm-powerful',
+        },
+    },
+    ruvllm: {
+        name: 'RuvLLM',
+        type: 'local',
+        models: {
+            fast: 'ruvllm-fast',
+            balanced: 'ruvllm-balanced',
+            powerful: 'ruvllm-powerful',
+        },
+    },
+    // Cloud providers as fallback (December 2025 models)
     anthropic: {
         name: 'Anthropic Claude',
+        type: 'cloud',
         baseUrl: 'https://api.anthropic.com/v1',
         models: {
             fast: 'claude-3-5-haiku-20241022',
-            balanced: 'claude-3-5-sonnet-20241022',
-            powerful: 'claude-3-opus-20240229',
+            balanced: 'claude-sonnet-4-20250514',
+            powerful: 'claude-opus-4-5-20251101',
         },
         headers: (apiKey) => ({
             'Content-Type': 'application/json',
@@ -36,11 +58,12 @@ const LLM_PROVIDERS = {
     },
     openai: {
         name: 'OpenAI',
+        type: 'cloud',
         baseUrl: 'https://api.openai.com/v1',
         models: {
             fast: 'gpt-4o-mini',
-            balanced: 'gpt-4o',
-            powerful: 'gpt-4-turbo',
+            balanced: 'gpt-5.2',
+            powerful: 'gpt-5.2-turbo',
         },
         headers: (apiKey) => ({
             'Content-Type': 'application/json',
@@ -81,31 +104,62 @@ Generate high-quality embeddings for text. Optimize for similarity matching.`,
 // ============================================
 
 /**
- * Real LLM client that makes actual API calls
+ * Real LLM client - uses local ruvllm by default, falls back to cloud APIs
  */
 export class LLMClient {
     constructor(options = {}) {
-        this.provider = options.provider || 'anthropic';
+        // Default to local ruvllm, fallback to cloud if API key provided
+        this.provider = options.provider || 'local';
         this.apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
         this.model = options.model || 'balanced';
         this.maxTokens = options.maxTokens || 4096;
 
-        if (!this.apiKey) {
-            console.warn('[LLM] No API key found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY');
+        // Auto-select cloud provider if API key is set and provider not specified
+        if (!options.provider && this.apiKey) {
+            this.provider = process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai';
         }
 
         this.config = LLM_PROVIDERS[this.provider];
         if (!this.config) {
             throw new Error(`Unknown LLM provider: ${this.provider}`);
         }
+
+        // Initialize local LLM if using local provider
+        this.ruvllm = null;
+        this.ruvllmInitialized = false;
+    }
+
+    /**
+     * Initialize local ruvllm
+     */
+    async initLocal() {
+        if (this.ruvllmInitialized) return;
+
+        try {
+            const ruvllm = await import('@ruvector/ruvllm');
+            this.ruvllm = new ruvllm.RuvLLM({
+                embeddingDim: 768,
+                learningEnabled: true,
+            });
+            this.ruvllmInitialized = true;
+            console.log('[LLM] Initialized local RuvLLM engine');
+        } catch (error) {
+            console.warn('[LLM] RuvLLM not available:', error.message);
+        }
     }
 
     /**
-     * Call LLM API
+     * Call LLM - local or cloud
      */
     async complete(systemPrompt, userMessage, options = {}) {
+        const isLocal = this.config.type === 'local';
+
+        if (isLocal) {
+            return this.callLocal(systemPrompt, userMessage, options);
+        }
+
         if (!this.apiKey) {
-            throw new Error('No API key configured. Set ANTHROPIC_API_KEY or OPENAI_API_KEY');
+            throw new Error('No API key configured. Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or use provider: "local"');
         }
 
         const model = this.config.models[options.model || this.model];
@@ -117,6 +171,71 @@ export class LLMClient {
         }
     }
 
+    /**
+     * Call local RuvLLM
+     */
+    async callLocal(systemPrompt, userMessage, options = {}) {
+        await this.initLocal();
+
+        const modelTier = options.model || this.model;
+        const prompt = `${systemPrompt}\n\n${userMessage}`;
+
+        if (this.ruvllm) {
+            // Use real ruvllm engine
+            const response = this.ruvllm.query(prompt, {
+                maxTokens: options.maxTokens || this.maxTokens,
+                temperature: options.temperature || 0.7,
+            });
+
+            return {
+                content: response.text,
+                model: `ruvllm-${modelTier}`,
+                usage: { input_tokens: prompt.length, output_tokens: response.text.length },
+                stopReason: 'end',
+                confidence: response.confidence,
+                local: true,
+            };
+        }
+
+        // Fallback: Generate response using local heuristics
+        console.log('[LLM] Using fallback local generation');
+        const fallbackResponse = this.generateFallbackResponse(systemPrompt, userMessage);
+
+        return {
+            content: fallbackResponse,
+            model: `ruvllm-${modelTier}-fallback`,
+            usage: { input_tokens: prompt.length, output_tokens: fallbackResponse.length },
+            stopReason: 'end',
+            local: true,
+            fallback: true,
+        };
+    }
+
+    /**
+     * Generate fallback response for basic tasks
+     */
+    generateFallbackResponse(systemPrompt, userMessage) {
+        // Basic task-specific responses
+        if (systemPrompt.includes('research')) {
+            return `Based on the query "${userMessage.slice(0, 100)}...", here are the key findings:\n\n1. The topic requires further investigation.\n2. Multiple sources should be consulted.\n3. Consider the context and requirements carefully.\n\nNote: This is a local fallback response. For more detailed analysis, ensure ruvllm is properly installed.`;
+        }
+
+        if (systemPrompt.includes('coding') || systemPrompt.includes('code')) {
+            return `Here's a code solution for: ${userMessage.slice(0, 50)}...\n\n\`\`\`javascript\n// Implementation based on the requirements\nfunction solution() {\n  // TODO: Implement the specific logic\n  console.log('Task:', '${userMessage.slice(0, 30)}...');\n  return { success: true };\n}\n\`\`\`\n\nNote: This is a local fallback. Install ruvllm for real code generation.`;
+        }
+
+        if (systemPrompt.includes('review')) {
+            return `Code Review for: ${userMessage.slice(0, 50)}...\n\n**Summary:** The code structure appears reasonable.\n\n**Suggestions:**\n- Add error handling\n- Consider edge cases\n- Add documentation\n\nNote: This is a local fallback response.`;
+        }
+
+        if (systemPrompt.includes('test')) {
+            return `Test Plan for: ${userMessage.slice(0, 50)}...\n\n\`\`\`javascript\ndescribe('Feature', () => {\n  it('should work correctly', () => {\n    // Test implementation\n    expect(true).toBe(true);\n  });\n});\n\`\`\`\n\nNote: This is a local fallback response.`;
+        }
+
+        // Generic response
+        return `Response to: ${userMessage.slice(0, 100)}...\n\nThis is a local response generated without cloud API calls. For full LLM capabilities:\n1. Install @ruvector/ruvllm for local AI\n2. Or set ANTHROPIC_API_KEY/OPENAI_API_KEY for cloud\n\nTask acknowledged and processed locally.`;
+    }
+
     async callAnthropic(systemPrompt, userMessage, model, options = {}) {
         const response = await fetch(`${this.config.baseUrl}/messages`, {
             method: 'POST',
@@ -175,8 +294,17 @@ export class LLMClient {
      * Check if LLM is configured
      */
     isConfigured() {
+        // Local is always configured
+        if (this.config.type === 'local') return true;
         return !!this.apiKey;
     }
+
+    /**
+     * Check if using local provider
+     */
+    isLocal() {
+        return this.config.type === 'local';
+    }
 }
 
 // ============================================
@@ -198,7 +326,12 @@ export class RealEmbedder {
             // Try to load ruvector's AdaptiveEmbedder
             const { AdaptiveEmbedder } = await import('ruvector');
             this.embedder = new AdaptiveEmbedder();
-            await this.embedder.initialize();
+            // Support both init() and initialize() methods
+            if (typeof this.embedder.init === 'function') {
+                await this.embedder.init();
+            } else if (typeof this.embedder.initialize === 'function') {
+                await this.embedder.initialize();
+            }
             this.initialized = true;
             console.log('[Embedder] Initialized ruvector AdaptiveEmbedder');
             return true;