@ruvector/edge-net 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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",
@@ -114,5 +114,9 @@
     "network": "node network.js stats",
     "peers": "node join.js --peers",
     "history": "node join.js --history"
+  },
+  "dependencies": {
+    "@ruvector/ruvllm": "^0.2.3",
+    "@xenova/transformers": "^2.17.2"
   }
 }

package/real-agents.js

@@ -21,19 +21,57 @@ import { join } from 'path';
 // ============================================
 
 const LLM_PROVIDERS = {
-    // LOCAL LLM - Default, no API key needed
+    // ONNX LLM via transformers.js - Default, no API key needed
+    // Uses real ONNX models (SmolLM, TinyLlama, etc.)
     local: {
-        name: 'RuvLLM Local',
+        name: 'ONNX Local',
         type: 'local',
+        backend: 'onnx', // Primary: transformers.js ONNX
         models: {
-            fast: 'ruvllm-fast',
-            balanced: 'ruvllm-balanced',
-            powerful: 'ruvllm-powerful',
+            // TRM (Tiny Random Models) - Fastest
+            fast: process.env.ONNX_MODEL_FAST || 'Xenova/distilgpt2',
+            // SmolLM - Better quality
+            balanced: process.env.ONNX_MODEL || 'HuggingFaceTB/SmolLM-135M-Instruct',
+            // TinyLlama - Best small model
+            powerful: process.env.ONNX_MODEL_POWERFUL || 'HuggingFaceTB/SmolLM-360M-Instruct',
+        },
+    },
+    onnx: {
+        name: 'ONNX Transformers.js',
+        type: 'local',
+        backend: 'onnx',
+        models: {
+            // TRM - Ultra tiny models
+            'trm-tinystories': 'Xenova/TinyStories-33M',
+            'trm-gpt2': 'Xenova/gpt2',
+            'trm-distilgpt2': 'Xenova/distilgpt2',
+            // SmolLM series
+            fast: 'HuggingFaceTB/SmolLM-135M-Instruct',
+            balanced: 'HuggingFaceTB/SmolLM-360M-Instruct',
+            powerful: 'TinyLlama/TinyLlama-1.1B-Chat-v1.0',
+            // Named models
+            'smollm-135m': 'HuggingFaceTB/SmolLM-135M-Instruct',
+            'smollm-360m': 'HuggingFaceTB/SmolLM-360M-Instruct',
+            'smollm2-135m': 'HuggingFaceTB/SmolLM2-135M-Instruct',
+            'tinyllama': 'TinyLlama/TinyLlama-1.1B-Chat-v1.0',
+            'qwen2.5-0.5b': 'Qwen/Qwen2.5-0.5B-Instruct',
+        },
+    },
+    ollama: {
+        name: 'Ollama',
+        type: 'local',
+        backend: 'ollama',
+        baseUrl: process.env.OLLAMA_HOST || 'http://localhost:11434',
+        models: {
+            fast: process.env.OLLAMA_MODEL_FAST || 'qwen2.5:0.5b',
+            balanced: process.env.OLLAMA_MODEL || 'qwen2.5:1.5b',
+            powerful: process.env.OLLAMA_MODEL_POWERFUL || 'qwen2.5:3b',
         },
     },
     ruvllm: {
-        name: 'RuvLLM',
+        name: 'RuvLLM (Legacy)',
         type: 'local',
+        backend: 'ruvllm',
         models: {
             fast: 'ruvllm-fast',
             balanced: 'ruvllm-balanced',
@@ -124,13 +162,92 @@ export class LLMClient {
             throw new Error(`Unknown LLM provider: ${this.provider}`);
         }
 
-        // Initialize local LLM if using local provider
+        // Initialize local LLM backends
         this.ruvllm = null;
         this.ruvllmInitialized = false;
+        this.onnxPipeline = null;
+        this.onnxInitialized = false;
+        this.onnxModel = null;
+    }
+
+    /**
+     * Initialize ONNX LLM via transformers.js
+     * This is the primary local inference method
+     */
+    async initOnnx(modelId) {
+        if (this.onnxInitialized && this.onnxModel === modelId) return true;
+
+        try {
+            console.log(`[LLM] Loading ONNX model: ${modelId}...`);
+            console.log('[LLM] First load may take a few minutes to download the model...');
+
+            const transformers = await import('@xenova/transformers');
+            const { pipeline, env } = transformers;
+
+            // Configure cache
+            env.cacheDir = process.env.ONNX_CACHE_DIR ||
+                (process.env.HOME ? `${process.env.HOME}/.ruvector/models/onnx` : '/tmp/.ruvector/models/onnx');
+            env.allowRemoteModels = true;
+            env.allowLocalModels = true;
+
+            // Create text generation pipeline
+            this.onnxPipeline = await pipeline('text-generation', modelId, {
+                quantized: true,
+                device: 'cpu',
+            });
+
+            this.onnxModel = modelId;
+            this.onnxInitialized = true;
+            console.log(`[LLM] ONNX model ready: ${modelId}`);
+            return true;
+        } catch (error) {
+            console.warn('[LLM] ONNX init failed:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Call ONNX LLM for text generation
+     */
+    async callOnnx(modelId, systemPrompt, userMessage, options = {}) {
+        await this.initOnnx(modelId);
+        if (!this.onnxPipeline) {
+            throw new Error('ONNX pipeline not initialized');
+        }
+
+        // Build prompt (simple format for small models)
+        const prompt = systemPrompt
+            ? `${systemPrompt}\n\nUser: ${userMessage}\n\nAssistant:`
+            : userMessage;
+
+        const start = Date.now();
+
+        const outputs = await this.onnxPipeline(prompt, {
+            max_new_tokens: options.maxTokens || 256,
+            temperature: options.temperature || 0.7,
+            top_p: options.topP || 0.9,
+            top_k: options.topK || 50,
+            repetition_penalty: 1.1,
+            do_sample: (options.temperature || 0.7) > 0,
+            return_full_text: false,
+        });
+
+        const timeMs = Date.now() - start;
+        const generatedText = outputs[0]?.generated_text || '';
+
+        return {
+            content: generatedText.trim(),
+            model: modelId,
+            timeMs,
+            usage: {
+                input_tokens: Math.ceil(prompt.length / 4),
+                output_tokens: Math.ceil(generatedText.length / 4),
+            },
+        };
     }
 
     /**
-     * Initialize local ruvllm
+     * Initialize legacy ruvllm
      */
     async initLocal() {
         if (this.ruvllmInitialized) return;
@@ -172,45 +289,377 @@ export class LLMClient {
     }
 
     /**
-     * Call local RuvLLM
+     * Call local LLM (ONNX primary, Ollama fallback)
      */
     async callLocal(systemPrompt, userMessage, options = {}) {
-        await this.initLocal();
-
         const modelTier = options.model || this.model;
-        const prompt = `${systemPrompt}\n\n${userMessage}`;
+        const modelName = this.config.models[modelTier] || this.config.models.balanced;
+        const backend = this.config.backend || 'onnx';
 
-        if (this.ruvllm) {
-            // Use real ruvllm engine
-            const response = this.ruvllm.query(prompt, {
-                maxTokens: options.maxTokens || this.maxTokens,
-                temperature: options.temperature || 0.7,
-            });
+        // ========================================
+        // 1. ONNX via transformers.js (Primary - REAL AI)
+        // ========================================
+        if (backend === 'onnx' || this.provider === 'local' || this.provider === 'onnx') {
+            try {
+                const onnxModelId = this.config.models[modelTier] || modelName;
+                const response = await this.callOnnx(onnxModelId, systemPrompt, userMessage, options);
+
+                // Validate response is meaningful
+                if (response.content && response.content.length > 5) {
+                    return {
+                        content: response.content,
+                        model: response.model,
+                        usage: response.usage,
+                        stopReason: 'end',
+                        local: true,
+                        onnx: true,
+                        timeMs: response.timeMs,
+                    };
+                }
+            } catch (error) {
+                console.log(`[LLM] ONNX not available: ${error.message}`);
+            }
+        }
+
+        // ========================================
+        // 2. Ollama (Fallback if ONNX unavailable)
+        // ========================================
+        if (backend === 'ollama' || this.config.baseUrl) {
+            const baseUrl = this.config.baseUrl || 'http://localhost:11434';
+            const ollamaModel = this.config.models[modelTier] || 'qwen2.5:0.5b';
+
+            try {
+                const response = await this.callOllama(baseUrl, ollamaModel, systemPrompt, userMessage, options);
+                if (response) {
+                    return {
+                        content: response.content,
+                        model: ollamaModel,
+                        usage: response.usage || { input_tokens: 0, output_tokens: 0 },
+                        stopReason: 'end',
+                        local: true,
+                        ollama: true,
+                    };
+                }
+            } catch (error) {
+                console.log(`[LLM] Ollama not available: ${error.message}`);
+            }
+        }
 
-            return {
-                content: response.text,
-                model: `ruvllm-${modelTier}`,
-                usage: { input_tokens: prompt.length, output_tokens: response.text.length },
-                stopReason: 'end',
-                confidence: response.confidence,
-                local: true,
-            };
+        // ========================================
+        // 3. Legacy RuvLLM (if explicitly selected)
+        // ========================================
+        if (backend === 'ruvllm' || this.provider === 'ruvllm') {
+            await this.initLocal();
+            if (this.ruvllm) {
+                const prompt = `${systemPrompt}\n\n${userMessage}`;
+                const response = this.ruvllm.query(prompt, {
+                    maxTokens: options.maxTokens || this.maxTokens,
+                    temperature: options.temperature || 0.7,
+                });
+
+                // Check if response is valid (not garbage)
+                const isValidResponse = response.text &&
+                    response.text.length > 10 &&
+                    /[a-zA-Z]{3,}/.test(response.text) &&
+                    !/^[>A-Z~|%#@\\+]+/.test(response.text);
+
+                if (isValidResponse) {
+                    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);
+        // ========================================
+        // 4. Smart Template Fallback (Last resort)
+        // ========================================
+        console.log('[LLM] Using smart template generation');
+        console.log('[LLM] Install @xenova/transformers for real ONNX AI inference');
+        const fallbackResponse = this.generateSmartResponse(systemPrompt, userMessage);
 
         return {
             content: fallbackResponse,
-            model: `ruvllm-${modelTier}-fallback`,
-            usage: { input_tokens: prompt.length, output_tokens: fallbackResponse.length },
+            model: `template-${modelTier}`,
+            usage: { input_tokens: systemPrompt.length + userMessage.length, output_tokens: fallbackResponse.length },
             stopReason: 'end',
             local: true,
             fallback: true,
         };
     }
 
+    /**
+     * Call Ollama API
+     */
+    async callOllama(baseUrl, model, systemPrompt, userMessage, options = {}) {
+        const url = `${baseUrl}/api/chat`;
+
+        const body = {
+            model,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: userMessage },
+            ],
+            stream: false,
+            options: {
+                temperature: options.temperature || 0.7,
+                num_predict: options.maxTokens || this.maxTokens,
+            },
+        };
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(options.timeout || 120000), // 2 min timeout
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Ollama error ${response.status}: ${errorText}`);
+        }
+
+        const result = await response.json();
+
+        return {
+            content: result.message?.content || '',
+            usage: {
+                input_tokens: result.prompt_eval_count || 0,
+                output_tokens: result.eval_count || 0,
+            },
+        };
+    }
+
+    /**
+     * Generate smart contextual response based on task type
+     */
+    generateSmartResponse(systemPrompt, userMessage) {
+        const task = userMessage.toLowerCase();
+        const promptLower = systemPrompt.toLowerCase();
+
+        // Review (check first - priority over code)
+        if (promptLower.includes('review') || task.includes('review')) {
+            return this.generateReviewResponse(userMessage);
+        }
+
+        // Test
+        if (promptLower.includes('test') || task.includes('test')) {
+            return this.generateTestResponse(userMessage);
+        }
+
+        // Research/analysis
+        if (promptLower.includes('research') || promptLower.includes('analy') || task.includes('research') || task.includes('analy')) {
+            return this.generateResearchResponse(userMessage);
+        }
+
+        // Code generation (check keywords in user message)
+        if (promptLower.includes('coding') || promptLower.includes('coder') ||
+            task.includes('write') || task.includes('function') || task.includes('implement') ||
+            task.includes('create') || task.includes('build')) {
+            return this.generateCodeResponse(userMessage);
+        }
+
+        // Default
+        return this.generateDefaultResponse(userMessage);
+    }
+
+    generateCodeResponse(task) {
+        const taskLower = task.toLowerCase();
+
+        if (taskLower.includes('hello world')) {
+            return `Here's a hello world implementation:
+
+\`\`\`javascript
+function helloWorld() {
+    console.log('Hello, World!');
+    return 'Hello, World!';
+}
+
+// Usage
+helloWorld();
+\`\`\`
+
+This function prints "Hello, World!" to the console and returns the string.`;
+        }
+
+        if (taskLower.includes('sort') || taskLower.includes('array')) {
+            return `Here's a sorting implementation:
+
+\`\`\`javascript
+function sortArray(arr, ascending = true) {
+    return [...arr].sort((a, b) => ascending ? a - b : b - a);
+}
+
+// Example usage
+const numbers = [5, 2, 8, 1, 9];
+console.log(sortArray(numbers));       // [1, 2, 5, 8, 9]
+console.log(sortArray(numbers, false)); // [9, 8, 5, 2, 1]
+\`\`\``;
+        }
+
+        if (taskLower.includes('fetch') || taskLower.includes('api') || taskLower.includes('http')) {
+            return `Here's an API fetch implementation:
+
+\`\`\`javascript
+async function fetchData(url, options = {}) {
+    try {
+        const response = await fetch(url, {
+            method: options.method || 'GET',
+            headers: { 'Content-Type': 'application/json', ...options.headers },
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+
+        if (!response.ok) {
+            throw new Error(\`HTTP error! status: \${response.status}\`);
+        }
+
+        return await response.json();
+    } catch (error) {
+        console.error('Fetch error:', error);
+        throw error;
+    }
+}
+
+// Usage
+const data = await fetchData('https://api.example.com/data');
+\`\`\``;
+        }
+
+        // Generic code response
+        return `Based on your request: "${task.slice(0, 100)}..."
+
+\`\`\`javascript
+// Implementation
+function solution(input) {
+    // Process input
+    const result = processInput(input);
+
+    // Apply transformation
+    const transformed = transform(result);
+
+    return transformed;
+}
+
+function processInput(data) {
+    // Validate and prepare data
+    return data;
+}
+
+function transform(data) {
+    // Apply business logic
+    return { success: true, data };
+}
+
+module.exports = { solution };
+\`\`\`
+
+This provides a basic structure. For a complete implementation, please specify the exact requirements or use a cloud provider (-p anthropic or -p openai).`;
+    }
+
+    generateResearchResponse(task) {
+        return `## Research Summary: ${task.slice(0, 60)}...
+
+### Key Findings
+
+1. **Overview**: This topic requires careful analysis of multiple factors.
+
+2. **Primary Considerations**:
+   - Understand the core requirements
+   - Identify key stakeholders and constraints
+   - Review existing solutions and best practices
+
+3. **Recommended Approach**:
+   - Start with a clear problem definition
+   - Gather data from reliable sources
+   - Validate assumptions with evidence
+
+4. **Next Steps**:
+   - Conduct detailed analysis
+   - Document findings
+   - Present recommendations
+
+*Note: For comprehensive research with real sources, use a cloud provider with -p anthropic or -p openai.*`;
+    }
+
+    generateReviewResponse(task) {
+        return `## Code Review Summary
+
+**Task**: ${task.slice(0, 80)}...
+
+### Assessment
+
+✅ **Strengths**:
+- Code structure appears organized
+- Basic functionality is present
+
+⚠️ **Suggestions for Improvement**:
+1. Add error handling for edge cases
+2. Include input validation
+3. Add JSDoc comments for documentation
+4. Consider adding unit tests
+5. Review for potential security issues
+
+### Recommendations
+- Follow consistent naming conventions
+- Extract repeated logic into helper functions
+- Add logging for debugging
+
+*For detailed code analysis, use a cloud provider.*`;
+    }
+
+    generateTestResponse(task) {
+        return `## Test Plan: ${task.slice(0, 60)}...
+
+\`\`\`javascript
+describe('Feature Tests', () => {
+    beforeEach(() => {
+        // Setup test environment
+    });
+
+    afterEach(() => {
+        // Cleanup
+    });
+
+    test('should handle normal input', () => {
+        const result = functionUnderTest(normalInput);
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+    });
+
+    test('should handle edge cases', () => {
+        expect(() => functionUnderTest(null)).toThrow();
+        expect(() => functionUnderTest(undefined)).toThrow();
+    });
+
+    test('should handle error conditions', () => {
+        const result = functionUnderTest(invalidInput);
+        expect(result.error).toBeDefined();
+    });
+});
+\`\`\`
+
+### Test Coverage Recommendations
+- Unit tests for core functions
+- Integration tests for API endpoints
+- Edge case testing
+- Performance benchmarks`;
+    }
+
+    generateDefaultResponse(task) {
+        return `Response to: ${task.slice(0, 100)}...
+
+This is a local response generated without cloud API calls. For full LLM capabilities:
+1. Install @ruvector/ruvllm for local AI
+2. Or set ANTHROPIC_API_KEY/OPENAI_API_KEY for cloud
+
+Task acknowledged and processed locally.`;
+    }
+
     /**
      * Generate fallback response for basic tasks
      */