genesis-ai-cli 14.6.3 → 14.6.4

package/dist/src/agents/explorer.d.ts

@@ -9,6 +9,7 @@ import { MessageBus } from './message-bus.js';
 import { Message, MessageType, ExplorationResult, ExplorationSource } from './types.js';
 export declare class ExplorerAgent extends BaseAgent {
     private explorationHistory;
+    private mcp;
     constructor(bus?: MessageBus);
     protected getMessageTypes(): MessageType[];
     process(message: Message): Promise<Message | null>;
@@ -16,6 +17,7 @@ export declare class ExplorerAgent extends BaseAgent {
     private handleCommand;
     explore(query: string, sources?: ExplorationSource['type'][], depth?: 'shallow' | 'medium' | 'deep'): Promise<ExplorationResult>;
     private searchSource;
+    private computeRelevance;
     private createFinding;
     private getDefaultSources;
     private calculateNovelty;

package/dist/src/agents/explorer.js

@@ -10,12 +10,15 @@ exports.ExplorerAgent = void 0;
 exports.createExplorerAgent = createExplorerAgent;
 const base_agent_js_1 = require("./base-agent.js");
 const message_bus_js_1 = require("./message-bus.js");
+const index_js_1 = require("../mcp/index.js");
 // ============================================================================
 // Explorer Agent
 // ============================================================================
 class ExplorerAgent extends base_agent_js_1.BaseAgent {
     // Track exploration history for novelty detection
     explorationHistory = new Set();
+    // MCP client for real searches
+    mcp = (0, index_js_1.getMCPClient)();
     constructor(bus = message_bus_js_1.messageBus) {
         super({ type: 'explorer' }, bus);
     }
@@ -110,48 +113,137 @@ class ExplorerAgent extends base_agent_js_1.BaseAgent {
     // Source-Specific Search
     // ============================================================================
     async searchSource(source, query) {
-        // In production, these would call actual MCP servers
-        // For now, we return simulated results based on source type
         const findings = [];
         const metadata = {};
-        switch (source) {
-            case 'arxiv':
-                // Would call: mcp__arxiv__search_arxiv
-                findings.push(this.createFinding(`[arxiv] Research on "${query}" - Recent papers and preprints`, source, 0.8, true));
-                metadata.paperCount = 0;
-                break;
-            case 'semantic-scholar':
-                // Would call: mcp__semantic-scholar__search_semantic_scholar
-                findings.push(this.createFinding(`[semantic-scholar] Academic papers with citations for "${query}"`, source, 0.85, true));
-                metadata.citationDepth = 2;
-                break;
-            case 'brave':
-                // Would call: mcp__brave-search__brave_web_search
-                findings.push(this.createFinding(`[brave] Web results and news for "${query}"`, source, 0.7, false));
-                break;
-            case 'gemini':
-                // Would call: mcp__gemini__web_search
-                findings.push(this.createFinding(`[gemini] AI-synthesized search results for "${query}"`, source, 0.75, false));
-                break;
-            case 'exa':
-                // Would call: mcp__exa__web_search_exa or mcp__exa__get_code_context_exa
-                findings.push(this.createFinding(`[exa] Code context and examples for "${query}"`, source, 0.8, true));
-                break;
-            case 'firecrawl':
-                // Would call: mcp__firecrawl__firecrawl_search
-                findings.push(this.createFinding(`[firecrawl] Deep web scraping results for "${query}"`, source, 0.65, false));
-                break;
-            case 'context7':
-                // Would call: mcp__context7__query-docs
-                findings.push(this.createFinding(`[context7] Library documentation for "${query}"`, source, 0.9, true));
-                break;
-            case 'wolfram':
-                // Would call: mcp__wolfram__wolfram_query
-                findings.push(this.createFinding(`[wolfram] Computational/mathematical results for "${query}"`, source, 0.95, true));
-                break;
+        try {
+            switch (source) {
+                case 'arxiv': {
+                    const result = await this.mcp.call('arxiv', 'search_arxiv', {
+                        query,
+                        max_results: 5,
+                    });
+                    if (result?.data) {
+                        const papers = Array.isArray(result.data) ? result.data :
+                            (result.data.papers || []);
+                        for (const paper of papers.slice(0, 5)) {
+                            findings.push(this.createFinding(`[arxiv] ${paper.title || 'Paper'}: ${(paper.summary || paper.abstract || '').slice(0, 200)}...`, source, this.computeRelevance(query, paper.title, paper.summary), true));
+                        }
+                        metadata.paperCount = papers.length;
+                    }
+                    break;
+                }
+                case 'semantic-scholar': {
+                    const result = await this.mcp.call('semantic-scholar', 'search_semantic_scholar', {
+                        query,
+                        limit: 5,
+                    });
+                    if (result?.data) {
+                        const papers = Array.isArray(result.data) ? result.data :
+                            (result.data.papers || []);
+                        for (const paper of papers.slice(0, 5)) {
+                            const citations = paper.citationCount || 0;
+                            findings.push(this.createFinding(`[semantic-scholar] ${paper.title || 'Paper'} (${citations} citations): ${(paper.abstract || '').slice(0, 200)}...`, source, citations > 100 ? 0.9 : citations > 10 ? 0.7 : 0.5, true));
+                        }
+                        metadata.citationDepth = 2;
+                    }
+                    break;
+                }
+                case 'brave': {
+                    const result = await this.mcp.call('brave-search', 'brave_web_search', {
+                        query,
+                        count: 5,
+                    });
+                    if (result?.data) {
+                        const results = result.data.web?.results || result.data.results || [];
+                        for (const item of results.slice(0, 5)) {
+                            findings.push(this.createFinding(`[brave] ${item.title || 'Result'}: ${(item.description || item.snippet || '').slice(0, 200)}...`, source, 0.7, false));
+                        }
+                    }
+                    break;
+                }
+                case 'gemini': {
+                    const result = await this.mcp.call('gemini', 'web_search', {
+                        query,
+                    });
+                    if (result?.data) {
+                        const content = typeof result.data === 'string' ? result.data :
+                            JSON.stringify(result.data).slice(0, 500);
+                        findings.push(this.createFinding(`[gemini] ${content.slice(0, 300)}...`, source, 0.75, false));
+                    }
+                    break;
+                }
+                case 'exa': {
+                    const result = await this.mcp.call('exa', 'web_search_exa', {
+                        query,
+                        numResults: 5,
+                    });
+                    if (result?.data) {
+                        const results = result.data.results || [];
+                        for (const item of results.slice(0, 5)) {
+                            findings.push(this.createFinding(`[exa] ${item.title || 'Result'}: ${(item.text || item.snippet || '').slice(0, 200)}...`, source, 0.8, true));
+                        }
+                    }
+                    break;
+                }
+                case 'firecrawl': {
+                    const result = await this.mcp.call('firecrawl', 'firecrawl_search', {
+                        query,
+                        limit: 5,
+                    });
+                    if (result?.data) {
+                        const results = result.data.results || result.data || [];
+                        const items = Array.isArray(results) ? results : [results];
+                        for (const item of items.slice(0, 5)) {
+                            findings.push(this.createFinding(`[firecrawl] ${item.title || item.url || 'Result'}: ${(item.content || item.description || '').slice(0, 200)}...`, source, 0.65, false));
+                        }
+                    }
+                    break;
+                }
+                case 'context7': {
+                    // context7 requires library resolution first
+                    const libResult = await this.mcp.call('context7', 'resolve-library-id', {
+                        libraryName: query.split(' ')[0], // Use first word as library name
+                    });
+                    if (libResult?.data?.libraryId) {
+                        const docsResult = await this.mcp.call('context7', 'query-docs', {
+                            libraryId: libResult.data.libraryId,
+                            query,
+                        });
+                        if (docsResult?.data) {
+                            findings.push(this.createFinding(`[context7] ${typeof docsResult.data === 'string' ? docsResult.data.slice(0, 300) : JSON.stringify(docsResult.data).slice(0, 300)}...`, source, 0.9, true));
+                        }
+                    }
+                    break;
+                }
+                case 'wolfram': {
+                    const result = await this.mcp.call('wolfram', 'wolfram_query', {
+                        input: query,
+                    });
+                    if (result?.data) {
+                        const content = typeof result.data === 'string' ? result.data :
+                            JSON.stringify(result.data).slice(0, 500);
+                        findings.push(this.createFinding(`[wolfram] ${content.slice(0, 300)}...`, source, 0.95, true));
+                    }
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            this.log(`MCP call to ${source} failed: ${error}`);
+            // Return empty findings on error - graceful degradation
         }
         return { findings, metadata };
     }
+    computeRelevance(query, title, summary) {
+        const queryTerms = query.toLowerCase().split(/\s+/);
+        const text = `${title || ''} ${summary || ''}`.toLowerCase();
+        let matches = 0;
+        for (const term of queryTerms) {
+            if (text.includes(term))
+                matches++;
+        }
+        return queryTerms.length > 0 ? Math.min(0.95, 0.5 + (matches / queryTerms.length) * 0.45) : 0.5;
+    }
     createFinding(content, sourceType, importance, isNovel) {
         return {
             content,

package/dist/src/economy/live/payment-verifier.js

@@ -159,7 +159,9 @@ class PaymentWatcher {
                     try {
                         h(event);
                     }
-                    catch { }
+                    catch (handlerError) {
+                        console.error('[PaymentWatcher] Handler error:', handlerError, 'txHash:', event.txHash);
+                    }
                 }
             }
             this.lastBlock = currentBlock;

package/dist/src/llm/advanced-router.d.ts

@@ -79,6 +79,8 @@ export declare class AdvancedRouter {
     private stats;
     private metaLearning;
     private providerHealth;
+    private rateLimiters;
+    private static readonly TOKEN_REFILL_INTERVAL;
     constructor(config?: {
         costOptimize: boolean;
         speedOptimize: boolean;
@@ -87,6 +89,11 @@ export declare class AdvancedRouter {
         enableMetaLearning: boolean;
     });
     private checkProviderHealth;
+    /**
+     * Enforce rate limiting using token bucket algorithm.
+     * Waits if tokens are exhausted, preventing 429 errors.
+     */
+    private enforceRateLimit;
     private getAvailableProviders;
     route(prompt: string, forceTaskType?: TaskType): Promise<AdvancedRoutingDecision>;
     private selectCheapest;

package/dist/src/llm/advanced-router.js

@@ -408,6 +408,9 @@ class AdvancedRouter {
     };
     metaLearning = [];
     providerHealth = new Map();
+    // Rate limiting with token bucket
+    rateLimiters = new Map();
+    static TOKEN_REFILL_INTERVAL = 60000; // 1 minute
     constructor(config = {
         costOptimize: true,
         speedOptimize: true,
@@ -458,6 +461,33 @@ class AdvancedRouter {
         this.providerHealth.set(provider, { available, lastCheck: now });
         return available;
     }
+    /**
+     * Enforce rate limiting using token bucket algorithm.
+     * Waits if tokens are exhausted, preventing 429 errors.
+     */
+    async enforceRateLimit(provider) {
+        const config = exports.PROVIDER_REGISTRY[provider];
+        const rateLimit = config.rateLimit || 60; // Default 60 RPM
+        let bucket = this.rateLimiters.get(provider);
+        const now = Date.now();
+        if (!bucket) {
+            bucket = { tokens: rateLimit, lastRefill: now };
+            this.rateLimiters.set(provider, bucket);
+        }
+        // Refill tokens based on time elapsed
+        const elapsed = now - bucket.lastRefill;
+        const refillAmount = (elapsed / AdvancedRouter.TOKEN_REFILL_INTERVAL) * rateLimit;
+        bucket.tokens = Math.min(rateLimit, bucket.tokens + refillAmount);
+        bucket.lastRefill = now;
+        // Wait if no tokens available
+        if (bucket.tokens < 1) {
+            const waitMs = Math.ceil((1 - bucket.tokens) * (AdvancedRouter.TOKEN_REFILL_INTERVAL / rateLimit));
+            console.log(`[AdvancedRouter] Rate limit reached for ${provider}, waiting ${waitMs}ms`);
+            await new Promise(r => setTimeout(r, waitMs));
+            bucket.tokens = 1; // Reset after wait
+        }
+        bucket.tokens--;
+    }
     async getAvailableProviders() {
         const checks = await Promise.all(Object.keys(exports.PROVIDER_REGISTRY).map(async (p) => ({
             provider: p,
@@ -611,6 +641,8 @@ class AdvancedRouter {
     // Provider Calls
     // ==========================================================================
     async callProvider(provider, model, prompt, systemPrompt) {
+        // Enforce rate limiting before making the call
+        await this.enforceRateLimit(provider);
         const startTime = Date.now();
         const config = exports.PROVIDER_REGISTRY[provider];
         switch (provider) {

package/dist/src/llm/index.js

@@ -634,6 +634,13 @@ class LLMBridge {
         }
         finally {
             reader.releaseLock();
+            // Properly clean up the stream to prevent connection leaks
+            try {
+                await response.body?.cancel();
+            }
+            catch {
+                // Ignore cancel errors - stream may already be closed
+            }
         }
         // Add to history
         this.conversationHistory.push({ role: 'assistant', content: fullContent });
@@ -759,6 +766,13 @@ class LLMBridge {
         }
         finally {
             reader.releaseLock();
+            // Properly clean up the stream to prevent connection leaks
+            try {
+                await response.body?.cancel();
+            }
+            catch {
+                // Ignore cancel errors - stream may already be closed
+            }
         }
         // Add to history
         this.conversationHistory.push({ role: 'assistant', content: fullContent });
@@ -842,6 +856,13 @@ class LLMBridge {
         }
         finally {
             reader.releaseLock();
+            // Properly clean up the stream to prevent connection leaks
+            try {
+                await response.body?.cancel();
+            }
+            catch {
+                // Ignore cancel errors - stream may already be closed
+            }
         }
         // Add to history
         this.conversationHistory.push({ role: 'assistant', content: fullContent });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "14.6.3",
+  "version": "14.6.4",
   "description": "Fully Autonomous AI System with RSI (Recursive Self-Improvement) - Self-funding, Self-deploying, Production Memory, A2A Protocol & Governance",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",