agentic-qe 2.3.5 → 2.5.0

package/dist/providers/RuvllmProvider.js

@@ -1,11 +1,10 @@
 "use strict";
 /**
- * RuvllmProvider - Local LLM Inference via ruvllm
+ * RuvllmProvider - Local LLM Inference via @ruvector/ruvllm
  *
- * Provides local LLM inference for cost-effective operations on capable hardware.
- * Uses ruvllm for fast local inference with support for various open models.
- *
- * Features:
+ * Provides local LLM inference with advanced features:
+ * - TRM (Test-time Reasoning & Metacognition) for iterative refinement
+ * - SONA (Self-Organizing Neural Architecture) for continuous learning
  * - Zero cloud costs for local inference
  * - Low latency for local operations
  * - Privacy-preserving (no data leaves the machine)
@@ -13,18 +12,26 @@
  * - Model hot-swapping
  *
  * @module providers/RuvllmProvider
- * @version 1.0.0
+ * @version 2.0.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuvllmProvider = void 0;
 const child_process_1 = require("child_process");
 const ILLMProvider_1 = require("./ILLMProvider");
 const Logger_1 = require("../utils/Logger");
+const ruvllm_loader_1 = require("../utils/ruvllm-loader");
 /**
- * RuvllmProvider - Local LLM inference implementation of ILLMProvider
+ * RuvllmProvider - Local LLM inference implementation with TRM and SONA
  *
- * This provider enables local LLM inference using ruvllm, providing
- * cost-free, low-latency inference for development and privacy-sensitive tasks.
+ * This provider enables local LLM inference using @ruvector/ruvllm, providing
+ * cost-free, low-latency inference with advanced learning capabilities.
+ *
+ * Features:
+ * - TRM for iterative quality improvement
+ * - SONA for continuous learning from trajectories
+ * - ReasoningBank for pattern reuse
+ * - Memory search for context-aware responses
+ * - LoRA adapters for task-specific optimization
  */
 class RuvllmProvider {
     constructor(config = {}) {
@@ -41,14 +48,23 @@ class RuvllmProvider {
             contextSize: config.contextSize ?? 4096,
             threads: config.threads ?? 4,
             defaultTemperature: config.defaultTemperature ?? 0.7,
-            enableEmbeddings: config.enableEmbeddings ?? false
+            enableEmbeddings: config.enableEmbeddings ?? false,
+            enableTRM: config.enableTRM ?? true,
+            enableSONA: config.enableSONA ?? true,
+            maxTRMIterations: config.maxTRMIterations ?? 7,
+            convergenceThreshold: config.convergenceThreshold ?? 0.95,
+            sonaConfig: {
+                loraRank: config.sonaConfig?.loraRank ?? 8,
+                loraAlpha: config.sonaConfig?.loraAlpha ?? 16,
+                ewcLambda: config.sonaConfig?.ewcLambda ?? 2000
+            }
         };
         this.isInitialized = false;
         this.baseUrl = `http://localhost:${this.config.port}`;
         this.requestCount = 0;
     }
     /**
-     * Initialize the ruvllm provider
+     * Initialize the ruvllm provider with TRM and SONA support
      */
     async initialize() {
         if (this.isInitialized) {
@@ -56,20 +72,53 @@ class RuvllmProvider {
             return;
         }
         try {
-            // Check if server is already running
+            // Load ruvLLM via CJS (ESM build is broken)
+            const ruvllmModule = (0, ruvllm_loader_1.loadRuvLLM)();
+            if (!ruvllmModule) {
+                // Check if server is already running (fallback mode)
+                const isRunning = await this.checkServerHealth();
+                if (isRunning) {
+                    this.isInitialized = true;
+                    this.logger.info('Connected to existing ruvllm server (fallback mode, ruvLLM lib unavailable)');
+                    return;
+                }
+                throw new Error('RuvLLM library not available and no server running');
+            }
+            // Initialize RuvLLM core
+            this.ruvllm = new ruvllmModule.RuvLLM({
+                learningEnabled: this.config.enableSONA ?? true,
+                embeddingDim: 768,
+                ewcLambda: this.config.sonaConfig?.ewcLambda ?? 2000
+            });
+            // Initialize SONA components if enabled
+            if (this.config.enableSONA) {
+                this.sonaCoordinator = new ruvllmModule.SonaCoordinator();
+                this.reasoningBank = new ruvllmModule.ReasoningBank(0.85); // 85% similarity threshold
+                // Initialize LoRA manager
+                this.loraManager = new ruvllmModule.LoraManager();
+                this.logger.info('SONA components initialized', {
+                    loraRank: this.config.sonaConfig?.loraRank,
+                    loraAlpha: this.config.sonaConfig?.loraAlpha,
+                    ewcLambda: this.config.sonaConfig?.ewcLambda
+                });
+            }
+            // Check if server is already running (fallback mode)
             const isRunning = await this.checkServerHealth();
             if (isRunning) {
                 this.isInitialized = true;
-                this.logger.info('Connected to existing ruvllm server');
+                this.logger.info('Connected to existing ruvllm server (fallback mode)');
                 return;
             }
-            // Start ruvllm server
+            // Start ruvllm server as fallback
             await this.startServer();
             this.isInitialized = true;
             this.logger.info('RuvllmProvider initialized', {
                 model: this.config.defaultModel,
                 port: this.config.port,
-                gpuLayers: this.config.gpuLayers
+                gpuLayers: this.config.gpuLayers,
+                enableTRM: this.config.enableTRM,
+                enableSONA: this.config.enableSONA,
+                maxTRMIterations: this.config.maxTRMIterations
             });
         }
         catch (error) {
@@ -77,72 +126,307 @@ class RuvllmProvider {
         }
     }
     /**
-     * Complete a prompt using local inference
+     * Complete a prompt using ruvLLM with optional TRM refinement
      */
     async complete(options) {
         this.ensureInitialized();
+        // Use TRM if enabled and configured
+        if (this.config.enableTRM && options.trmConfig) {
+            const trmResponse = await this.completeTRM(options);
+            return trmResponse;
+        }
+        return this.completeBasic(options);
+    }
+    /**
+     * Complete with TRM (Test-time Reasoning & Metacognition)
+     */
+    async completeTRM(options) {
+        const maxIterations = options.trmConfig?.maxIterations ?? this.config.maxTRMIterations ?? 7;
+        const convergenceThreshold = options.trmConfig?.convergenceThreshold ?? this.config.convergenceThreshold ?? 0.95;
+        const qualityMetric = options.trmConfig?.qualityMetric ?? 'coherence';
         const startTime = Date.now();
-        try {
-            // Build request body
-            const requestBody = {
-                model: options.model || this.config.defaultModel,
-                messages: options.messages.map(m => ({
-                    role: m.role,
-                    content: typeof m.content === 'string' ? m.content : m.content.map(c => c.text || '').join('')
-                })),
-                max_tokens: options.maxTokens || 2048,
-                temperature: options.temperature ?? this.config.defaultTemperature,
-                stream: false
-            };
-            // Add system message if provided
-            if (options.system && options.system.length > 0) {
-                const systemContent = options.system.map(s => s.text).join('\n');
-                requestBody.messages = [
-                    { role: 'system', content: systemContent },
-                    ...requestBody.messages
-                ];
-            }
-            const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(requestBody),
-                signal: AbortSignal.timeout(this.config.timeout)
+        const history = [];
+        // Initial completion
+        let current = await this.completeBasic(options);
+        let quality = this.measureQuality(current, qualityMetric);
+        history.push({
+            iteration: 0,
+            quality,
+            improvement: 0,
+            reasoning: 'Initial completion'
+        });
+        this.logger.debug('TRM iteration 0', { quality, metric: qualityMetric });
+        // Iterative refinement
+        for (let i = 1; i < maxIterations; i++) {
+            // Refine using previous output
+            const refined = await this.refineTRM(current, options, qualityMetric);
+            const newQuality = this.measureQuality(refined, qualityMetric);
+            const improvement = newQuality - quality;
+            history.push({
+                iteration: i,
+                quality: newQuality,
+                improvement,
+                reasoning: `Refinement iteration ${i}`
             });
-            if (!response.ok) {
-                throw new Error(`Server returned ${response.status}: ${await response.text()}`);
+            this.logger.debug(`TRM iteration ${i}`, { quality: newQuality, improvement });
+            // Check convergence
+            if (improvement < (1 - convergenceThreshold)) {
+                this.logger.info('TRM converged', { iterations: i + 1, finalQuality: newQuality });
+                break;
             }
-            const data = await response.json();
-            this.requestCount++;
-            // Map to standard response format
-            const result = {
-                content: [{
-                        type: 'text',
-                        text: data.choices?.[0]?.message?.content || ''
-                    }],
-                usage: {
-                    input_tokens: data.usage?.prompt_tokens || 0,
-                    output_tokens: data.usage?.completion_tokens || 0
-                },
-                model: data.model || this.config.defaultModel,
-                stop_reason: this.mapStopReason(data.choices?.[0]?.finish_reason),
-                id: data.id || `ruvllm-${Date.now()}`,
-                metadata: {
-                    latency: Date.now() - startTime,
-                    cost: 0 // Local inference is free
-                }
-            };
-            this.logger.debug('Ruvllm completion successful', {
-                model: result.model,
-                inputTokens: result.usage.input_tokens,
-                outputTokens: result.usage.output_tokens,
-                latency: result.metadata?.latency
-            });
-            return result;
+            current = refined;
+            quality = newQuality;
+        }
+        // Track trajectory if SONA enabled
+        if (this.config.enableSONA && this.sonaCoordinator) {
+            await this.trackTrajectory(this.extractInput(options), this.extractOutput(current), quality);
+        }
+        return {
+            ...current,
+            trmIterations: history.length,
+            finalQuality: quality,
+            convergenceHistory: history,
+            metadata: {
+                ...current.metadata,
+                trmLatency: Date.now() - startTime,
+                qualityMetric
+            }
+        };
+    }
+    /**
+     * Basic completion without TRM
+     */
+    async completeBasic(options) {
+        const startTime = Date.now();
+        try {
+            // Check if ruvLLM instance is available
+            if (this.ruvllm) {
+                // Use ruvLLM query API
+                const input = this.extractInput(options);
+                // Search memory for relevant context
+                const memoryResults = this.ruvllm.searchMemory(input, 5);
+                // Query with routing
+                const response = this.ruvllm.query(input, {
+                    maxTokens: options.maxTokens || 2048,
+                    temperature: options.temperature ?? this.config.defaultTemperature
+                });
+                // Build response
+                const result = {
+                    content: [{
+                            type: 'text',
+                            text: response.text || ''
+                        }],
+                    usage: {
+                        input_tokens: response.contextSize || 0,
+                        output_tokens: this.estimateTokens(response.text || '')
+                    },
+                    model: response.model || this.config.defaultModel,
+                    stop_reason: 'end_turn',
+                    id: response.requestId || `ruvllm-${Date.now()}`,
+                    metadata: {
+                        latency: response.latencyMs || (Date.now() - startTime),
+                        confidence: response.confidence,
+                        memoryHits: memoryResults.length,
+                        cost: 0
+                    }
+                };
+                // Add to memory
+                this.ruvllm.addMemory(response.text, {
+                    input,
+                    timestamp: Date.now(),
+                    model: response.model
+                });
+                this.requestCount++;
+                return result;
+            }
+            // Fallback to OpenAI-compatible API
+            return this.completeViaServer(options, startTime);
         }
         catch (error) {
             throw new ILLMProvider_1.LLMProviderError(`Ruvllm completion failed: ${error.message}`, 'ruvllm', 'INFERENCE_ERROR', true, error);
         }
     }
+    /**
+     * Complete via OpenAI-compatible server (fallback)
+     */
+    async completeViaServer(options, startTime) {
+        const requestBody = {
+            model: options.model || this.config.defaultModel,
+            messages: options.messages.map(m => ({
+                role: m.role,
+                content: typeof m.content === 'string' ? m.content : m.content.map(c => c.text || '').join('')
+            })),
+            max_tokens: options.maxTokens || 2048,
+            temperature: options.temperature ?? this.config.defaultTemperature,
+            stream: false
+        };
+        // Add system message if provided
+        if (options.system && options.system.length > 0) {
+            const systemContent = options.system.map(s => s.text).join('\n');
+            requestBody.messages = [
+                { role: 'system', content: systemContent },
+                ...requestBody.messages
+            ];
+        }
+        const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody),
+            signal: AbortSignal.timeout(this.config.timeout)
+        });
+        if (!response.ok) {
+            throw new Error(`Server returned ${response.status}: ${await response.text()}`);
+        }
+        const data = await response.json();
+        this.requestCount++;
+        return {
+            content: [{
+                    type: 'text',
+                    text: data.choices?.[0]?.message?.content || ''
+                }],
+            usage: {
+                input_tokens: data.usage?.prompt_tokens || 0,
+                output_tokens: data.usage?.completion_tokens || 0
+            },
+            model: data.model || this.config.defaultModel,
+            stop_reason: this.mapStopReason(data.choices?.[0]?.finish_reason),
+            id: data.id || `ruvllm-${Date.now()}`,
+            metadata: {
+                latency: Date.now() - startTime,
+                cost: 0
+            }
+        };
+    }
+    /**
+     * Refine output using TRM
+     */
+    async refineTRM(previous, options, metric) {
+        const previousText = previous.content[0].text;
+        // Create refinement prompt
+        const refinementMessages = [
+            ...options.messages,
+            {
+                role: 'assistant',
+                content: previousText
+            },
+            {
+                role: 'user',
+                content: `Review and improve the above response to maximize ${metric}. Provide a refined version that addresses any weaknesses.`
+            }
+        ];
+        return this.completeBasic({
+            ...options,
+            messages: refinementMessages
+        });
+    }
+    /**
+     * Measure quality of a completion
+     */
+    measureQuality(response, metric) {
+        const text = response.content[0].text;
+        switch (metric) {
+            case 'coherence':
+                return this.measureCoherence(text);
+            case 'coverage':
+                return this.measureCoverage(text);
+            case 'diversity':
+                return this.measureDiversity(text);
+            default:
+                return this.measureCoherence(text);
+        }
+    }
+    /**
+     * Measure coherence (sentence flow, structure)
+     */
+    measureCoherence(text) {
+        const sentences = text.split(/[.!?]+/).filter(s => s.trim().length > 0);
+        if (sentences.length === 0)
+            return 0;
+        // Simple heuristics:
+        // - Longer responses are more coherent
+        // - More sentences indicate better structure
+        // - Normalized by length to avoid bias
+        const avgSentenceLength = text.length / sentences.length;
+        const normalizedLength = Math.min(avgSentenceLength / 100, 1.0);
+        const sentenceCount = Math.min(sentences.length / 10, 1.0);
+        return (normalizedLength + sentenceCount) / 2;
+    }
+    /**
+     * Measure coverage (breadth of content)
+     */
+    measureCoverage(text) {
+        // Measure unique words as proxy for coverage
+        const words = text.toLowerCase().split(/\s+/);
+        const uniqueWords = new Set(words);
+        if (words.length === 0)
+            return 0;
+        return Math.min(uniqueWords.size / words.length, 1.0);
+    }
+    /**
+     * Measure diversity (variety in expression)
+     */
+    measureDiversity(text) {
+        // Measure vocabulary richness
+        const words = text.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+        const uniqueWords = new Set(words);
+        if (words.length === 0)
+            return 0;
+        // Type-token ratio
+        return Math.min(uniqueWords.size / words.length * 2, 1.0);
+    }
+    /**
+     * Track trajectory in SONA
+     */
+    async trackTrajectory(input, output, confidence) {
+        if (!this.sonaCoordinator)
+            return;
+        try {
+            const ruvllmModule = (0, ruvllm_loader_1.loadRuvLLM)();
+            if (!ruvllmModule)
+                return;
+            const trajectory = new ruvllmModule.TrajectoryBuilder()
+                .startStep('query', input)
+                .endStep(output, confidence)
+                .complete('success');
+            this.sonaCoordinator.recordTrajectory(trajectory);
+            // Store in reasoning bank if high confidence
+            // ReasoningBank.store(type, embedding, metadata)
+            if (this.reasoningBank && confidence > 0.85 && this.ruvllm) {
+                const rawEmbedding = this.ruvllm.embed(input);
+                // Convert Float32Array to number[] for ReasoningBank
+                const embedding = Array.from(rawEmbedding);
+                this.reasoningBank.store('query_response', embedding, {
+                    input,
+                    output,
+                    confidence,
+                    timestamp: Date.now()
+                });
+            }
+            this.logger.debug('Trajectory tracked', { confidence, hasReasoningBank: !!this.reasoningBank });
+        }
+        catch (error) {
+            this.logger.warn('Failed to track trajectory', { error: error.message });
+        }
+    }
+    /**
+     * Extract input text from options
+     */
+    extractInput(options) {
+        const messages = options.messages.map(m => typeof m.content === 'string' ? m.content : m.content.map(c => c.text || '').join(''));
+        return messages.join(' ');
+    }
+    /**
+     * Extract output text from response
+     */
+    extractOutput(response) {
+        return response.content.map(c => c.text).join('');
+    }
+    /**
+     * Estimate token count
+     */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
     /**
      * Stream a completion
      */
@@ -219,14 +503,26 @@ class RuvllmProvider {
         }
     }
     /**
-     * Generate embeddings
+     * Generate embeddings using ruvLLM
      */
     async embed(options) {
         this.ensureInitialized();
-        if (!this.config.enableEmbeddings) {
-            throw new ILLMProvider_1.LLMProviderError('Embeddings not enabled. Set enableEmbeddings: true in config.', 'ruvllm', 'UNSUPPORTED', false);
-        }
         try {
+            // Use ruvLLM embedding if available
+            if (this.ruvllm) {
+                const rawEmbedding = this.ruvllm.embed(options.text);
+                // Convert Float32Array to number[] for consistent return type
+                const embedding = Array.from(rawEmbedding);
+                return {
+                    embedding,
+                    model: options.model || 'ruvllm-embedding',
+                    tokens: this.estimateTokens(options.text)
+                };
+            }
+            // Fallback to server API
+            if (!this.config.enableEmbeddings) {
+                throw new ILLMProvider_1.LLMProviderError('Embeddings not enabled. Set enableEmbeddings: true in config.', 'ruvllm', 'UNSUPPORTED', false);
+            }
             const response = await fetch(`${this.baseUrl}/v1/embeddings`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
@@ -253,9 +549,7 @@ class RuvllmProvider {
      * Count tokens in text
      */
     async countTokens(options) {
-        // Approximate token count (ruvllm doesn't have a direct endpoint)
-        // Most models use ~4 characters per token
-        return Math.ceil(options.text.length / 4);
+        return this.estimateTokens(options.text);
     }
     /**
      * Health check
@@ -263,6 +557,22 @@ class RuvllmProvider {
     async healthCheck() {
         const startTime = Date.now();
         try {
+            // Check ruvLLM instance
+            if (this.ruvllm) {
+                return {
+                    healthy: true,
+                    latency: Date.now() - startTime,
+                    timestamp: new Date(),
+                    metadata: {
+                        model: this.config.defaultModel,
+                        requestCount: this.requestCount,
+                        sonaEnabled: !!this.sonaCoordinator,
+                        trmEnabled: this.config.enableTRM,
+                        mode: 'native'
+                    }
+                };
+            }
+            // Fallback to server health check
             const isHealthy = await this.checkServerHealth();
             return {
                 healthy: isHealthy,
@@ -271,7 +581,8 @@ class RuvllmProvider {
                 metadata: {
                     model: this.config.defaultModel,
                     port: this.config.port,
-                    requestCount: this.requestCount
+                    requestCount: this.requestCount,
+                    mode: 'server'
                 }
             };
         }
@@ -289,7 +600,7 @@ class RuvllmProvider {
     getMetadata() {
         return {
             name: 'ruvllm',
-            version: '1.0.0',
+            version: '2.0.0',
             models: [
                 'llama-3.2-3b-instruct',
                 'llama-3.2-1b-instruct',
@@ -305,7 +616,7 @@ class RuvllmProvider {
                 vision: false
             },
             costs: {
-                inputPerMillion: 0, // Free for local inference
+                inputPerMillion: 0,
                 outputPerMillion: 0
             },
             location: 'local'
@@ -319,6 +630,11 @@ class RuvllmProvider {
             this.serverProcess.kill();
             this.serverProcess = undefined;
         }
+        // Clean up ruvLLM resources
+        this.ruvllm = undefined;
+        this.sonaCoordinator = undefined;
+        this.reasoningBank = undefined;
+        this.loraManager = undefined;
         this.isInitialized = false;
         this.logger.info('RuvllmProvider shutdown', {
             requestCount: this.requestCount
@@ -328,10 +644,10 @@ class RuvllmProvider {
      * Track cost (always 0 for local inference)
      */
     trackCost(usage) {
-        return 0; // Local inference is free
+        return 0;
     }
     /**
-     * Start the ruvllm server
+     * Start the ruvllm server (fallback mode)
      */
     async startServer() {
         return new Promise((resolve, reject) => {
@@ -378,7 +694,7 @@ class RuvllmProvider {
         });
     }
     /**
-     * Check if server is healthy
+     * Check if server is healthy (fallback mode)
      */
     async checkServerHealth() {
         try {