@ruvector/edge-net 0.1.7 → 0.2.0

package/onnx-worker.js

@@ -0,0 +1,482 @@
+/**
+ * @ruvector/edge-net ONNX Worker Module
+ *
+ * Real semantic embeddings and LLM inference for workers
+ * Uses @xenova/transformers for actual AI inference
+ *
+ * @module @ruvector/edge-net/onnx-worker
+ */
+
+import { EventEmitter } from 'events';
+import { randomBytes } from 'crypto';
+
+// ============================================
+// ONNX EMBEDDER (REAL SEMANTIC EMBEDDINGS)
+// ============================================
+
+let transformers = null;
+let embeddingPipeline = null;
+let textGenPipeline = null;
+let loadedEmbedModel = null;
+let loadedGenModel = null;
+
+/**
+ * Available embedding models (smallest first)
+ */
+export const EMBEDDING_MODELS = {
+    'minilm-l6': {
+        id: 'Xenova/all-MiniLM-L6-v2',
+        dimensions: 384,
+        size: '~22MB',
+        description: 'Fast, good quality embeddings',
+    },
+    'minilm-l12': {
+        id: 'Xenova/all-MiniLM-L12-v2',
+        dimensions: 384,
+        size: '~33MB',
+        description: 'Better quality, slightly slower',
+    },
+    'gte-small': {
+        id: 'Xenova/gte-small',
+        dimensions: 384,
+        size: '~67MB',
+        description: 'High quality embeddings',
+    },
+    'bge-small': {
+        id: 'Xenova/bge-small-en-v1.5',
+        dimensions: 384,
+        size: '~33MB',
+        description: 'Best for retrieval tasks',
+    },
+};
+
+/**
+ * Available text generation models
+ */
+export const GENERATION_MODELS = {
+    'distilgpt2': {
+        id: 'Xenova/distilgpt2',
+        size: '~82MB',
+        description: 'Fast text generation',
+    },
+    'gpt2': {
+        id: 'Xenova/gpt2',
+        size: '~250MB',
+        description: 'Classic GPT-2',
+    },
+    'tinystories': {
+        id: 'Xenova/TinyStories-33M',
+        size: '~65MB',
+        description: 'Ultra-small for stories',
+    },
+};
+
+/**
+ * Initialize transformers.js
+ */
+async function initTransformers() {
+    if (transformers) return transformers;
+
+    try {
+        transformers = await import('@xenova/transformers');
+
+        // Configure cache
+        const { env } = transformers;
+        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;
+
+        return transformers;
+    } catch (error) {
+        console.error('[ONNX Worker] transformers.js not available:', error.message);
+        return null;
+    }
+}
+
+/**
+ * Initialize embedding model
+ */
+export async function initEmbedding(modelKey = 'minilm-l6') {
+    const tf = await initTransformers();
+    if (!tf) return false;
+
+    const model = EMBEDDING_MODELS[modelKey] || EMBEDDING_MODELS['minilm-l6'];
+
+    if (embeddingPipeline && loadedEmbedModel === model.id) {
+        return true;
+    }
+
+    try {
+        console.error(`[ONNX] Loading embedding model: ${model.id}...`);
+        const { pipeline } = tf;
+        embeddingPipeline = await pipeline('feature-extraction', model.id, {
+            quantized: true,
+        });
+        loadedEmbedModel = model.id;
+        console.error(`[ONNX] Embedding model ready: ${model.id}`);
+        return true;
+    } catch (error) {
+        console.error('[ONNX] Failed to load embedding model:', error.message);
+        return false;
+    }
+}
+
+/**
+ * Initialize text generation model
+ */
+export async function initGeneration(modelKey = 'distilgpt2') {
+    const tf = await initTransformers();
+    if (!tf) return false;
+
+    const model = GENERATION_MODELS[modelKey] || GENERATION_MODELS['distilgpt2'];
+
+    if (textGenPipeline && loadedGenModel === model.id) {
+        return true;
+    }
+
+    try {
+        console.error(`[ONNX] Loading generation model: ${model.id}...`);
+        const { pipeline } = tf;
+        textGenPipeline = await pipeline('text-generation', model.id, {
+            quantized: true,
+        });
+        loadedGenModel = model.id;
+        console.error(`[ONNX] Generation model ready: ${model.id}`);
+        return true;
+    } catch (error) {
+        console.error('[ONNX] Failed to load generation model:', error.message);
+        return false;
+    }
+}
+
+/**
+ * Generate real semantic embeddings
+ */
+export async function embed(texts, options = {}) {
+    const initialized = await initEmbedding(options.model);
+
+    if (!initialized || !embeddingPipeline) {
+        // Fallback to hash-based embeddings
+        return fallbackEmbed(texts);
+    }
+
+    const inputTexts = Array.isArray(texts) ? texts : [texts];
+    const startTime = performance.now();
+
+    try {
+        const results = [];
+
+        for (const text of inputTexts) {
+            const output = await embeddingPipeline(text, {
+                pooling: 'mean',
+                normalize: true,
+            });
+
+            // Convert tensor to array
+            const embedding = Array.from(output.data);
+
+            results.push({
+                text: text.slice(0, 100),
+                embedding,
+                dimensions: embedding.length,
+                semantic: true,
+            });
+        }
+
+        const timeMs = performance.now() - startTime;
+
+        return {
+            embeddings: results,
+            model: loadedEmbedModel,
+            timeMs,
+            count: results.length,
+            semantic: true,
+        };
+    } catch (error) {
+        console.error('[ONNX] Embedding error:', error.message);
+        return fallbackEmbed(texts);
+    }
+}
+
+/**
+ * Fallback hash-based embeddings
+ */
+function fallbackEmbed(texts) {
+    const inputTexts = Array.isArray(texts) ? texts : [texts];
+
+    const results = inputTexts.map(text => {
+        const hash = createHash('sha256').update(String(text)).digest();
+        const embedding = new Float32Array(384);
+        for (let i = 0; i < 384; i++) {
+            embedding[i] = (hash[i % 32] - 128) / 128;
+        }
+        return {
+            text: String(text).slice(0, 100),
+            embedding: Array.from(embedding),
+            dimensions: 384,
+            semantic: false,
+        };
+    });
+
+    return {
+        embeddings: results,
+        model: 'hash-fallback',
+        count: results.length,
+        semantic: false,
+    };
+}
+
+/**
+ * Generate text using ONNX LLM
+ */
+export async function generate(prompt, options = {}) {
+    const initialized = await initGeneration(options.model);
+
+    if (!initialized || !textGenPipeline) {
+        return {
+            text: `[Fallback] Processing: ${prompt.slice(0, 50)}...`,
+            model: 'fallback',
+            semantic: false,
+        };
+    }
+
+    const startTime = performance.now();
+
+    try {
+        const outputs = await textGenPipeline(prompt, {
+            max_new_tokens: options.maxTokens || 64,
+            temperature: options.temperature || 0.7,
+            top_p: options.topP || 0.9,
+            do_sample: true,
+            return_full_text: false,
+        });
+
+        const timeMs = performance.now() - startTime;
+        const generatedText = outputs[0]?.generated_text || '';
+
+        return {
+            text: generatedText.trim(),
+            model: loadedGenModel,
+            timeMs,
+            tokensPerSecond: Math.round((generatedText.split(/\s+/).length * 1.3) / (timeMs / 1000)),
+            semantic: true,
+        };
+    } catch (error) {
+        console.error('[ONNX] Generation error:', error.message);
+        return {
+            text: `[Error] ${error.message}`,
+            model: 'error',
+            semantic: false,
+        };
+    }
+}
+
+/**
+ * Compute similarity between two texts
+ */
+export async function similarity(text1, text2, options = {}) {
+    const result = await embed([text1, text2], options);
+
+    if (result.embeddings.length < 2) {
+        return { similarity: 0, semantic: false };
+    }
+
+    const e1 = result.embeddings[0].embedding;
+    const e2 = result.embeddings[1].embedding;
+
+    // Cosine similarity
+    let dotProduct = 0;
+    let norm1 = 0;
+    let norm2 = 0;
+
+    for (let i = 0; i < e1.length; i++) {
+        dotProduct += e1[i] * e2[i];
+        norm1 += e1[i] * e1[i];
+        norm2 += e2[i] * e2[i];
+    }
+
+    const cosineSim = dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
+
+    return {
+        similarity: cosineSim,
+        text1: text1.slice(0, 50),
+        text2: text2.slice(0, 50),
+        model: result.model,
+        semantic: result.semantic,
+    };
+}
+
+/**
+ * Semantic search - find most similar texts
+ */
+export async function semanticSearch(query, documents, options = {}) {
+    const topK = options.topK || 5;
+
+    // Embed query and documents together
+    const allTexts = [query, ...documents];
+    const result = await embed(allTexts, options);
+
+    if (result.embeddings.length < 2) {
+        return { results: [], semantic: false };
+    }
+
+    const queryEmbed = result.embeddings[0].embedding;
+    const docEmbeds = result.embeddings.slice(1);
+
+    // Calculate similarities
+    const scores = docEmbeds.map((doc, index) => {
+        let dotProduct = 0;
+        let norm1 = 0;
+        let norm2 = 0;
+
+        for (let i = 0; i < queryEmbed.length; i++) {
+            dotProduct += queryEmbed[i] * doc.embedding[i];
+            norm1 += queryEmbed[i] * queryEmbed[i];
+            norm2 += doc.embedding[i] * doc.embedding[i];
+        }
+
+        return {
+            index,
+            text: documents[index],
+            score: dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2)),
+        };
+    });
+
+    // Sort by score and return top K
+    scores.sort((a, b) => b.score - a.score);
+
+    return {
+        query,
+        results: scores.slice(0, topK),
+        model: result.model,
+        semantic: result.semantic,
+    };
+}
+
+// ============================================
+// ONNX WORKER POOL
+// ============================================
+
+/**
+ * Enhanced worker pool with ONNX capabilities
+ */
+export class OnnxWorkerPool extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.id = `onnx-pool-${randomBytes(6).toString('hex')}`;
+        this.embedModel = options.embedModel || 'minilm-l6';
+        this.genModel = options.genModel || 'distilgpt2';
+        this.initialized = false;
+
+        this.stats = {
+            embeddings: 0,
+            generations: 0,
+            searches: 0,
+            totalTimeMs: 0,
+        };
+    }
+
+    /**
+     * Initialize ONNX models
+     */
+    async initialize() {
+        this.emit('status', 'Initializing ONNX models...');
+
+        // Initialize embedding model
+        const embedReady = await initEmbedding(this.embedModel);
+
+        // Initialize generation model (optional)
+        const genReady = await initGeneration(this.genModel);
+
+        this.initialized = embedReady;
+
+        this.emit('ready', {
+            poolId: this.id,
+            embedding: embedReady,
+            generation: genReady,
+        });
+
+        return this;
+    }
+
+    /**
+     * Execute an ONNX task
+     */
+    async execute(type, data, options = {}) {
+        const startTime = performance.now();
+        let result;
+
+        switch (type) {
+            case 'embed':
+                result = await embed(data, options);
+                this.stats.embeddings++;
+                break;
+
+            case 'generate':
+                result = await generate(data, options);
+                this.stats.generations++;
+                break;
+
+            case 'similarity':
+                result = await similarity(data.text1, data.text2, options);
+                break;
+
+            case 'search':
+                result = await semanticSearch(data.query, data.documents, options);
+                this.stats.searches++;
+                break;
+
+            default:
+                throw new Error(`Unknown task type: ${type}`);
+        }
+
+        this.stats.totalTimeMs += performance.now() - startTime;
+
+        return result;
+    }
+
+    /**
+     * Batch embed documents
+     */
+    async embedBatch(texts, options = {}) {
+        return this.execute('embed', texts, options);
+    }
+
+    /**
+     * Semantic search
+     */
+    async search(query, documents, options = {}) {
+        return this.execute('search', { query, documents }, options);
+    }
+
+    /**
+     * Get pool status
+     */
+    getStatus() {
+        return {
+            poolId: this.id,
+            initialized: this.initialized,
+            embedModel: loadedEmbedModel,
+            genModel: loadedGenModel,
+            stats: this.stats,
+        };
+    }
+
+    /**
+     * Shutdown pool
+     */
+    async shutdown() {
+        embeddingPipeline = null;
+        textGenPipeline = null;
+        loadedEmbedModel = null;
+        loadedGenModel = null;
+        this.initialized = false;
+    }
+}
+
+// ============================================
+// EXPORTS
+// ============================================
+
+export default OnnxWorkerPool;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "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.",
+  "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, ONNX inference, WebRTC signaling, CRDT ledger, and multi-agent workflows.",
   "main": "ruvector_edge_net.js",
   "module": "ruvector_edge_net.js",
   "types": "ruvector_edge_net.d.ts",
@@ -35,7 +35,15 @@
     "worker-pools",
     "multi-agent",
     "webrtc",
-    "task-orchestration"
+    "task-orchestration",
+    "onnx",
+    "semantic-search",
+    "crdt",
+    "ledger",
+    "signaling",
+    "scheduler",
+    "monitoring",
+    "qdag"
   ],
   "author": "RuVector Team <team@ruvector.dev>",
   "license": "MIT",
@@ -65,6 +73,12 @@
     "real-workers.js",
     "real-workflows.js",
     "sync.js",
+    "onnx-worker.js",
+    "signaling.js",
+    "qdag.js",
+    "ledger.js",
+    "scheduler.js",
+    "monitor.js",
     "README.md",
     "LICENSE"
   ],
@@ -96,6 +110,24 @@
     },
     "./webrtc": {
       "import": "./webrtc.js"
+    },
+    "./onnx-worker": {
+      "import": "./onnx-worker.js"
+    },
+    "./signaling": {
+      "import": "./signaling.js"
+    },
+    "./qdag": {
+      "import": "./qdag.js"
+    },
+    "./ledger": {
+      "import": "./ledger.js"
+    },
+    "./scheduler": {
+      "import": "./scheduler.js"
+    },
+    "./monitor": {
+      "import": "./monitor.js"
     }
   },
   "sideEffects": [
@@ -113,10 +145,13 @@
     "join:multi": "node join.js --generate",
     "network": "node network.js stats",
     "peers": "node join.js --peers",
-    "history": "node join.js --history"
+    "history": "node join.js --history",
+    "signaling": "node -e \"import('./signaling.js').then(m => new m.SignalingServer().start())\"",
+    "monitor": "node -e \"import('./monitor.js').then(m => { const mon = new m.Monitor(); mon.start(); setInterval(() => console.log(JSON.stringify(mon.generateReport(), null, 2)), 5000); })\""
   },
   "dependencies": {
     "@ruvector/ruvllm": "^0.2.3",
-    "@xenova/transformers": "^2.17.2"
+    "@xenova/transformers": "^2.17.2",
+    "ws": "^8.18.3"
   }
 }