nyxora 26.6.26 → 26.6.28

package/README.md

@@ -97,8 +97,21 @@ To dive deeper into the technical details of our Zero-Knowledge security archite
 
 ## 🚀 Quick Start & Installation
 
-### Option 1: Global Installation (Recommended)
-Nyxora can be installed globally via NPM, allowing you to use the `nyxora` CLI command from anywhere on your machine.
+### Option 1: One-Line Installation (Recommended)
+The fastest way to install Nyxora is via our smart installation wrapper. This script automatically prepares Node.js (if missing) and securely fetches the Nyxora daemon directly from the NPM Registry.
+
+**Linux & macOS:**
+```bash
+curl -fsSL https://nyxoraai.github.io/Nyxora/install.sh | bash
+```
+
+**Windows (PowerShell):**
+```powershell
+iwr -useb https://nyxoraai.github.io/Nyxora/install.ps1 | iex
+```
+
+### Option 2: Global Installation (NPM)
+If you already have Node.js installed, you can natively install Nyxora globally via NPM, allowing you to use the `nyxora` CLI command from anywhere on your machine.
 
 ```bash
 # Install globally
@@ -124,7 +137,7 @@ cd Nyxora
 # 1. Install Dependencies
 npm install
 
-# 2. Build the Dashboard UI
+# 2. Build the Core, MCP Server, and Dashboard UI
 npm run build
 
 # 3. Interactive Setup Wizard
@@ -138,6 +151,13 @@ npm start
 
 > **⚠️ IMPORTANT:** Whenever you re-run `nyxora setup` or manually edit the config files, you **must restart the server** for the changes to take effect.
 
+### 🧹 Uninstallation & Reset
+If you ever need to securely wipe the AI's episodic memory, delete your API keys, and completely remove Nyxora's configuration from your operating system, simply run:
+```bash
+nyxora uninstall
+```
+This acts as a master reset switch to return your environment to a clean state.
+
 ---
 
 ## ⚖️ Terms of Service

package/bin/nyxora.mjs

@@ -350,6 +350,20 @@ async function unlock() {
   }
 }
 
+async function serveMcp() {
+  const compiledMcp = path.join(projectRoot, 'packages/mcp-server/dist/server.js');
+  const useCompiled = fs.existsSync(compiledMcp);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledMcp] : ['ts-node', '-T', 'packages/mcp-server/src/server.ts'];
+  const child = spawn(cmd, args, {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: { ...process.env, TS_NODE_CACHE: 'false' }
+  });
+  
+  await new Promise(resolve => child.on('close', resolve));
+}
+
 async function main() {
   switch(command) {
     case 'doctor': await runDoctor(); break;
@@ -366,6 +380,7 @@ async function main() {
     case 'unlock': await unlock(); break;
     case 'clean-logs': await cleanLogs(); break;
     case 'autostart': await autostart(process.argv[3]); break;
+    case 'mcp': await serveMcp(); break;
     case '-v':
     case '--v':
     case '--version':
@@ -383,6 +398,7 @@ Commands:
   start          Start the Nyxora background daemon
   stop           Stop the running daemon
   restart        Restart the daemon
+  mcp            Start the MCP Server directly (for testing/debug)
   chat           Chat interactively with the AI in terminal
   setup          Run the interactive Setup Wizard
   dashboard      Open the dashboard in your browser

package/dist/packages/core/src/agent/llmProvider.js

@@ -12,7 +12,8 @@ class OpenAIAdapter {
             message: {
                 content: response.choices[0].message.content,
                 tool_calls: response.choices[0].message.tool_calls
-            }
+            },
+            usage: response.usage ? { total_tokens: response.usage.total_tokens } : undefined
         };
     }
 }
@@ -124,7 +125,8 @@ class AnthropicAdapter {
             message: {
                 content: contentStr,
                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined
-            }
+            },
+            usage: response.usage ? { total_tokens: response.usage.input_tokens + response.usage.output_tokens } : undefined
         };
     }
 }
@@ -254,11 +256,16 @@ class GeminiAdapter {
                 }
             }
         }
+        let totalTokens = 0;
+        if (data.usageMetadata && data.usageMetadata.totalTokenCount) {
+            totalTokens = data.usageMetadata.totalTokenCount;
+        }
         return {
             message: {
                 content: contentStr,
                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined
-            }
+            },
+            usage: totalTokens > 0 ? { total_tokens: totalTokens } : undefined
         };
     }
 }

package/dist/packages/core/src/agent/web3Agent.js

@@ -69,7 +69,7 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
         const context = 'web3';
         const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
             // Debug log to find out why Gemini 400 error happens
-            console.log(`[LLM Debug] Sending ${messages.length} messages to LLM.`);
+            // console.log(`[LLM Debug] Sending ${messages.length} messages to LLM.`);
             return await client.chat({
                 model: config.llm.model,
                 temperature: config.llm.temperature,

package/dist/packages/core/src/config/marketConfigManager.js

@@ -8,8 +8,8 @@ exports.saveMarketKeys = saveMarketKeys;
 const fs_1 = __importDefault(require("fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const paths_1 = require("./paths");
-const MARKET_KEYS_FILE = (0, paths_1.getPath)('market_keys.yaml');
 function loadMarketKeys() {
+    const MARKET_KEYS_FILE = (0, paths_1.getPath)('market_keys.yaml');
     if (!fs_1.default.existsSync(MARKET_KEYS_FILE)) {
         return {};
     }
@@ -34,6 +34,7 @@ function saveMarketKeys(keys) {
                 delete updated[k];
             }
         }
+        const MARKET_KEYS_FILE = (0, paths_1.getPath)('market_keys.yaml');
         fs_1.default.writeFileSync(MARKET_KEYS_FILE, yaml_1.default.stringify(updated), 'utf8');
     }
     catch (error) {

package/dist/packages/core/src/config/parser.js

@@ -150,11 +150,6 @@ function loadConfig() {
                 needsSave = true;
             parsed.integrations.telegram.bot_token = decryptDataSync(parsed.integrations.telegram.bot_token);
         }
-        if (parsed.web3?.explorer_api_key) {
-            if (parsed.web3.explorer_api_key.startsWith('ENC:'))
-                needsSave = true;
-            parsed.web3.explorer_api_key = decryptDataSync(parsed.web3.explorer_api_key);
-        }
         // Auto-migration logic: move llm.credentials to root credentials
         if (parsed.llm && parsed.llm.credentials) {
             if (!parsed.credentials) {

package/dist/packages/core/src/gateway/WebSocketManager.js

@@ -26,7 +26,8 @@ class WebSocketManager {
                     return;
                 }
                 // Validate Auth Token during Upgrade Handshake
-                if (!(0, state_1.validateToken)(token)) {
+                const validation = (0, state_1.validateToken)(token);
+                if (!validation.valid) {
                     socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
                     socket.destroy();
                     return;

package/dist/packages/core/src/gateway/server.js

@@ -183,7 +183,7 @@ app.post('/api/upload-google-credentials', (req, res) => {
 app.get('/api/history', (req, res) => {
     try {
         const sessionId = req.query.session_id;
-        const history = reasoning_1.logger.getHistory(sessionId);
+        const history = reasoning_1.logger.getHistory(sessionId, 1000);
         // Filter out internal system prompt for the frontend
         const cleanHistory = history.filter((msg) => msg.role !== 'system');
         res.json(cleanHistory);
@@ -211,6 +211,18 @@ app.get('/api/sessions', (req, res) => {
         res.status(500).json({ error: error.message });
     }
 });
+app.get('/api/sessions/search', (req, res) => {
+    try {
+        const q = req.query.q;
+        if (!q) {
+            return res.json(reasoning_1.logger.getSessions());
+        }
+        res.json(reasoning_1.logger.searchSessions(q));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
 app.post('/api/sessions', (req, res) => {
     try {
         const { title } = req.body;
@@ -297,16 +309,20 @@ app.get('/api/defi-keys', (req, res) => {
         const { aggregatorRegistry } = require('../web3/aggregator/providerRegistry');
         const providers = aggregatorRegistry.getAllProviders();
         const requirements = [];
+        const seenKeys = new Set();
         for (const provider of providers) {
             if (provider.manifest.requiredApiKeys) {
                 for (const req of provider.manifest.requiredApiKeys) {
-                    requirements.push({
-                        id: req.id,
-                        label: req.label,
-                        required: req.required,
-                        docsUrl: req.docsUrl,
-                        configured: !!(keys[req.envKey] || keys[req.id])
-                    });
+                    if (!seenKeys.has(req.id)) {
+                        seenKeys.add(req.id);
+                        requirements.push({
+                            id: req.id,
+                            label: req.label,
+                            required: req.required,
+                            docsUrl: req.docsUrl,
+                            configured: !!keys[req.id]
+                        });
+                    }
                 }
             }
         }
@@ -325,6 +341,17 @@ app.post('/api/defi-keys', (req, res) => {
         res.status(500).json({ error: error.message });
     }
 });
+app.delete('/api/defi-keys/:id', (req, res) => {
+    try {
+        const keys = (0, defiConfigManager_1.loadDefiKeys)();
+        delete keys[req.params.id];
+        (0, defiConfigManager_1.saveDefiKeys)(keys);
+        res.json({ success: true });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
 app.get('/api/market-keys', (req, res) => {
     try {
         const keys = (0, marketConfigManager_1.loadMarketKeys)();
@@ -834,12 +861,15 @@ app.get('/api/portfolio', async (req, res) => {
 // --- Memory Triggers ---
 let messageCounter = 0;
 let idleTimer = null;
-function resetIdleTimer() {
+function resetIdleTimer(sessionId) {
     if (idleTimer)
         clearTimeout(idleTimer);
     idleTimer = setTimeout(() => {
         console.log('[Memory] Idle trigger activated. Running Reflection Engine...');
-        reflection_1.ReflectionEngine.runReflection();
+        reflection_1.ReflectionEngine.runReflection(sessionId).then(() => {
+            const { PromotionEngine } = require('../memory/promotionEngine');
+            PromotionEngine.runPromotionAndDecay();
+        }).catch(console.error);
     }, 3 * 60 * 1000); // 3 minutes idle
 }
 app.post('/api/v1/trade', async (req, res) => {
@@ -867,13 +897,16 @@ app.post('/api/chat', async (req, res) => {
         // Process input (this will automatically add to memory)
         const response = await (0, reasoning_1.processUserInput)(message, 'user', undefined, session_id);
         // Memory Triggers
-        resetIdleTimer();
+        resetIdleTimer(session_id);
         messageCounter++;
         if (messageCounter >= 5) {
             console.log('[Memory] N-Message threshold reached. Running Reflection Engine...');
             messageCounter = 0;
             // Run asynchronously
-            reflection_1.ReflectionEngine.runReflection();
+            reflection_1.ReflectionEngine.runReflection(session_id).then(() => {
+                const { PromotionEngine } = require('../memory/promotionEngine');
+                PromotionEngine.runPromotionAndDecay();
+            }).catch(console.error);
         }
         res.json({ response });
     }
@@ -891,6 +924,17 @@ app.get('/api/memory', (req, res) => {
         res.status(500).json({ error: error.message });
     }
 });
+app.delete('/api/memory/all', (req, res) => {
+    try {
+        episodic_1.episodicDB.clearAllMemories();
+        const { PromotionEngine } = require('../memory/promotionEngine');
+        PromotionEngine.runPromotionAndDecay();
+        res.json({ success: true, message: "Episodic memory wiped completely." });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
 app.delete('/api/memory/:id', (req, res) => {
     try {
         const id = parseInt(req.params.id, 10);
@@ -1025,6 +1069,22 @@ async function startServer() {
         (0, bridgeWatcher_1.startBridgeWatcher)();
         // Start Event Listener for Limit Orders (V3)
         eventListener_1.eventListener.start();
+        // Resume Market Watch tasks
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const { getAppDir } = require('../config/paths');
+            const tasksPath = path.join(getAppDir(), 'market_tasks.json');
+            if (fs.existsSync(tasksPath)) {
+                const tasks = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+                if (tasks.length > 0) {
+                    console.log(`[Market Watch] Resuming ${tasks.length} background watch tasks...`);
+                }
+            }
+        }
+        catch (e) {
+            console.error('[Market Watch] Failed to resume tasks:', e);
+        }
     });
     server.on('error', (e) => {
         if (e.code === 'EADDRINUSE') {

package/dist/packages/core/src/memory/episodic.js

@@ -36,16 +36,17 @@ class EpisodicMemoryDB {
     addCandidateFact(fact, confidenceScore = 0.5, category = 'general', ruleType = 'observation') {
         // Upsert logic
         const existing = this.db.prepare('SELECT id, occurrences, confidence FROM episodic_memories WHERE fact = ?').get(fact);
+        const safeScore = Math.min(1.0, confidenceScore);
         if (existing) {
             // Increment occurrences, boost confidence slightly up to max 1.0
             const newOccurrences = existing.occurrences + 1;
-            const newConfidence = Math.min(1.0, existing.confidence + (confidenceScore * 0.2)); // Dampened boost
+            const newConfidence = Math.min(1.0, existing.confidence + (safeScore * 0.2)); // Dampened boost
             const stmt = this.db.prepare('UPDATE episodic_memories SET occurrences = ?, confidence = ?, rule_type = ?, lastSeen = CURRENT_TIMESTAMP WHERE id = ?');
             stmt.run(newOccurrences, newConfidence, ruleType, existing.id);
         }
         else {
             const stmt = this.db.prepare('INSERT INTO episodic_memories (fact, confidence, category, rule_type) VALUES (?, ?, ?, ?)');
-            stmt.run(fact, confidenceScore, category, ruleType);
+            stmt.run(fact, safeScore, category, ruleType);
         }
     }
     getMemories() {
@@ -64,6 +65,10 @@ class EpisodicMemoryDB {
     `);
         stmt.run(minConfidence, daysOld);
     }
+    clearAllMemories() {
+        const stmt = this.db.prepare('DELETE FROM episodic_memories');
+        stmt.run();
+    }
     close() {
         try {
             this.db.close();

package/dist/packages/core/src/memory/logger.js

@@ -150,19 +150,29 @@ class Logger {
     renameSession(sessionId, newTitle) {
         this.db.prepare('UPDATE sessions SET title = ? WHERE id = ?').run(newTitle, sessionId);
     }
-    getHistory(sessionId) {
+    searchSessions(query) {
+        const term = `%${query}%`;
+        return this.db.prepare(`
+      SELECT DISTINCT s.* 
+      FROM sessions s
+      LEFT JOIN messages m ON s.id = m.session_id
+      WHERE s.title LIKE ? OR m.content LIKE ?
+      ORDER BY s.timestamp DESC
+    `).all(term, term);
+    }
+    getHistory(sessionId, limit = 40) {
         let rows;
         // Phase 2: Sliding Window Algorithm (LLM Context Limit)
-        // Fetch only the last 40 messages, then order them chronologically
+        // Fetch only the last X messages, then order them chronologically
         if (sessionId) {
             rows = this.db.prepare(`
         SELECT * FROM (
           SELECT role, content, name, tool_call_id, tool_calls, session_id, id 
           FROM messages 
           WHERE session_id = ? 
-          ORDER BY id DESC LIMIT 40
+          ORDER BY id DESC LIMIT ?
         ) ORDER BY id ASC
-      `).all(sessionId);
+      `).all(sessionId, limit);
         }
         else {
             rows = this.db.prepare(`
@@ -170,9 +180,9 @@ class Logger {
           SELECT role, content, name, tool_call_id, tool_calls, session_id, id 
           FROM messages 
           WHERE session_id IS NULL
-          ORDER BY id DESC LIMIT 40
+          ORDER BY id DESC LIMIT ?
         ) ORDER BY id ASC
-      `).all();
+      `).all(limit);
         }
         return rows.map((row) => {
             const entry = {

package/dist/packages/core/src/memory/reflection.js

@@ -7,24 +7,27 @@ const logger_1 = require("./logger");
 const validator_1 = require("./validator");
 const episodic_1 = require("./episodic");
 class ReflectionEngine {
-    static async runReflection() {
+    static async runReflection(sessionId) {
         try {
             // 1. Get recent session history
-            const history = logger_1.logger.getHistory();
-            if (history.length === 0)
+            const history = logger_1.logger.getHistory(sessionId);
+            if (history.length === 0) {
+                console.log('[ReflectionEngine] History is empty. Aborting reflection.');
                 return;
-            // Extract just the user and assistant text
+            }
+            // Extract just the user and assistant text, ignoring tool messages
             const recentChat = history
+                .filter(msg => msg.role !== 'tool')
                 .map(msg => `[${msg.role}]: ${msg.content}`)
                 .join('\n');
             const config = (0, parser_1.loadConfig)();
             const model = config.llm?.model || 'gpt-4o';
-            const openai = await (0, llmUtils_1.getOpenAI)();
+            const llm = await (0, llmUtils_1.getLLMClient)();
             // 2. Build the heavily constrained System Prompt
             const systemPrompt = `
 You are the Self-Reflection Engine for a Web3 AI Agent.
 Your job is to analyze the following recent conversation and extract user habits, preferences, or corrections.
-You MUST output ONLY valid JSON in the exact format specified.
+You MUST output ONLY valid JSON in the exact format specified. Do not include markdown code blocks around the JSON.
 
 CRITICAL RULES:
 1. DO NOT extract or remember any Private Keys, Seed Phrases, Mnemonic Words, Passwords, API Keys, or Session Tokens.
@@ -48,19 +51,20 @@ Return a JSON object with an array "memories":
 - rule_type "permanent": A strict reprimand or absolute preference (e.g., "Never use Ethereum!").
 `;
             // 3. Query LLM
-            const response = await openai.chat.completions.create({
+            const response = await llm.chat({
                 model: model,
                 messages: [
                     { role: 'system', content: systemPrompt },
                     { role: 'user', content: recentChat }
                 ],
-                response_format: { type: 'json_object' },
                 temperature: 0.1
             });
-            const content = response.choices[0]?.message?.content;
+            const content = response.message?.content;
             if (!content)
                 return;
-            const data = JSON.parse(content);
+            // Strip markdown codeblocks if LLM incorrectly formatted it
+            const cleanContent = content.replace(/```json/gi, '').replace(/```/g, '').trim();
+            const data = JSON.parse(cleanContent);
             const memories = data.memories || [];
             // 4. Validate and Store
             let addedCount = 0;
@@ -74,7 +78,7 @@ Return a JSON object with an array "memories":
                         // Fast-Track Override Logic
                         let confidence = 0.5; // default for observation
                         if (mem.rule_type === 'permanent')
-                            confidence = 2.0; // Fast-track override
+                            confidence = 1.0; // Fast-track override
                         if (mem.rule_type === 'temporary')
                             confidence = 0.8;
                         episodic_1.episodicDB.addCandidateFact(safeFact, confidence, mem.category || 'general', mem.rule_type || 'observation');

package/dist/packages/core/src/memory/validator.js

@@ -16,18 +16,7 @@ class MemoryValidator {
         if (privateKeyRegex.test(text)) {
             throw new Error('SECURITY VIOLATION: Potential Private Key detected in memory extraction.');
         }
-        // 2. Check for typical 12-24 word BIP-39 Mnemonic patterns.
-        // We do a rough heuristic: 12-24 lowercase words separated by spaces in a single block.
-        // This is hard to do perfectly with regex, so we look for sequences of 12+ words
-        const words = text.toLowerCase().match(/\b[a-z]+\b/g) || [];
-        if (words.length >= 12) {
-            // Very basic check: are there exactly 12 or 24 words in a continuous string?
-            const mnemonicRegex = /\b([a-z]+(?:\s+[a-z]+){11,23})\b/g;
-            if (mnemonicRegex.test(text.toLowerCase())) {
-                // Log it as suspicious, but we'll reject it to be safe if it looks like a seed phrase
-                throw new Error('SECURITY VIOLATION: Potential Seed Phrase detected in memory extraction.');
-            }
-        }
+        // Removed overly aggressive 12-word mnemonic check to avoid false positives in conversational languages
         // 3. Check for API/Bot Tokens (e.g., Telegram token format: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11)
         const telegramTokenRegex = /\b\d{8,10}:[a-zA-Z0-9_-]{35}\b/g;
         if (telegramTokenRegex.test(text)) {

package/dist/packages/core/src/utils/httpClient.js

@@ -26,16 +26,29 @@ async function safeFetch(url, options = {}) {
     for (let attempt = 0; attempt <= retries; attempt++) {
         const controller = new AbortController();
         const id = setTimeout(() => controller.abort(), timeoutMs);
+        const externalSignal = fetchOptions.signal;
+        const onExternalAbort = () => controller.abort();
+        if (externalSignal) {
+            if (externalSignal.aborted)
+                controller.abort();
+            else
+                externalSignal.addEventListener('abort', onExternalAbort);
+        }
+        const cleanup = () => {
+            clearTimeout(id);
+            if (externalSignal)
+                externalSignal.removeEventListener('abort', onExternalAbort);
+        };
         try {
             const res = await fetch(url, {
                 ...fetchOptions,
                 headers: finalHeaders,
                 signal: controller.signal
             });
-            clearTimeout(id);
+            cleanup();
             // Handle Rate Limits specifically with a forced retry if attempts remain
             if (res.status === 429) {
-                if (attempt < retries) {
+                if (attempt < retries && !controller.signal.aborted) {
                     // Coingecko and others often need longer backoff, exponentially increase
                     await delay(retryDelayMs * (attempt + 1) * 2);
                     continue;
@@ -44,7 +57,7 @@ async function safeFetch(url, options = {}) {
             }
             // Handle Server Errors with retry
             if (res.status >= 500) {
-                if (attempt < retries) {
+                if (attempt < retries && !controller.signal.aborted) {
                     await delay(retryDelayMs * (attempt + 1));
                     continue;
                 }
@@ -53,8 +66,12 @@ async function safeFetch(url, options = {}) {
             return res;
         }
         catch (error) {
-            clearTimeout(id);
+            cleanup();
             lastError = error;
+            // Do not retry if the external aggregator specifically aborted us
+            if (externalSignal && externalSignal.aborted) {
+                throw new HttpError(499, 'Client Closed Request', '');
+            }
             // AbortError is a timeout
             if (error.name === 'AbortError') {
                 if (attempt < retries) {
@@ -64,7 +81,7 @@ async function safeFetch(url, options = {}) {
                 throw new HttpError(408, 'Request Timeout', '');
             }
             // Network errors (like fetch failed)
-            if (attempt < retries) {
+            if (attempt < retries && !controller.signal.aborted) {
                 await delay(retryDelayMs * (attempt + 1));
                 continue;
             }

package/dist/packages/core/src/web3/aggregator/defiRouter.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.routeTransaction = routeTransaction;
 const routeSelector_1 = require("./routeSelector");
-async function routeTransaction(fromChain, toChain, fromToken, toToken, amountInWei, userAddress, slippageTolerance = "auto") {
+async function routeTransaction(fromChain, toChain, fromToken, toToken, amountInWei, amountFormatted, userAddress, slippageTolerance = "auto", providerName) {
     fromChain = String(fromChain || "");
     toChain = String(toChain || "");
     if (!fromChain || !toChain) {
@@ -35,8 +35,10 @@ async function routeTransaction(fromChain, toChain, fromToken, toToken, amountIn
         fromToken,
         toToken,
         amountInWei,
+        amountFormatted,
         userAddress,
-        slippageTolerance
+        slippageTolerance,
+        preferredProvider: providerName && providerName !== "auto" ? providerName : undefined
     };
     console.log(`[DeFi Router] Routing transaction via Extensible Provider Runtime...`);
     return await (0, routeSelector_1.fetchBestRoute)(request, "best_output");

package/dist/packages/core/src/web3/aggregator/providerRegistry.js

@@ -91,7 +91,14 @@ class AggregatorRegistry {
             fs_1.default.mkdirSync(providersDir, { recursive: true });
             return;
         }
-        const files = fs_1.default.readdirSync(providersDir).filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+        const isCompiled = __dirname.includes('dist') || __dirname.includes('build') || process.env.NODE_ENV === 'production';
+        const files = fs_1.default.readdirSync(providersDir).filter(f => {
+            if (f.endsWith('.d.ts'))
+                return false;
+            if (isCompiled)
+                return f.endsWith('.js');
+            return f.endsWith('.ts') || f.endsWith('.js');
+        });
         for (const file of files) {
             const fullPath = path_1.default.join(providersDir, file);
             try {

package/dist/packages/core/src/web3/aggregator/providers/KyberSwapProvider.js

@@ -38,7 +38,7 @@ class KyberSwapProvider {
         const slipParam = request.slippageTolerance === "auto" ? 50 : (request.slippageTolerance * 100);
         // Phase 1: Route
         const routeUrl = `https://aggregator-api.kyberswap.com/${chainName}/api/v1/routes?tokenIn=${request.fromToken}&tokenOut=${request.toToken}&amountIn=${request.amountInWei}`;
-        const routeRes = await (0, httpClient_1.safeFetch)(routeUrl, { signal: context.abortSignal });
+        const routeRes = await (0, httpClient_1.safeFetch)(routeUrl, { signal: context.abortSignal, retries: 0 });
         if (!routeRes.ok)
             throw new Error(`KyberSwap Route Error: ${await routeRes.text()}`);
         const routeData = await routeRes.json();
@@ -55,13 +55,17 @@ class KyberSwapProvider {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(buildPayload),
-            signal: context.abortSignal
+            signal: context.abortSignal,
+            retries: 0
         });
         if (!buildRes.ok)
             throw new Error(`KyberSwap Build Error: ${await buildRes.text()}`);
         const buildData = await buildRes.json();
-        const isNative = request.fromToken.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' ||
-            request.fromToken === '0x0000000000000000000000000000000000000000';
+        // KyberSwap returns calldata in 'data' field, and router address in 'routerAddress'
+        if (!buildData.data || !buildData.data.routerAddress || !buildData.data.data) {
+            throw new Error(`KyberSwap build response missing required fields (routerAddress or data). Got: ${JSON.stringify(Object.keys(buildData.data || {}))}`);
+        }
+        const isNative = request.fromToken.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
         return {
             provider: this.manifest.name,
             routeId: `kyber-${crypto_1.default.randomUUID()}`,

package/dist/packages/core/src/web3/aggregator/providers/LifiProvider.js

@@ -44,17 +44,29 @@ class LifiProvider {
     async getQuote(request, context) {
         const key = context.apiKeys['lifi_key'];
         const slipParam = request.slippageTolerance === "auto" ? 0.005 : (request.slippageTolerance / 100);
-        const url = `https://li.quest/v1/quote?fromChain=${request.fromChain}&toChain=${request.toChain}&fromToken=${request.fromToken}&toToken=${request.toToken}&fromAmount=${request.amountInWei}&fromAddress=${request.userAddress}&slippage=${slipParam}`;
+        const fromChainId = CHAIN_IDS[request.fromChain];
+        const toChainId = CHAIN_IDS[request.toChain];
+        const url = `https://li.quest/v1/quote?fromChain=${fromChainId}&toChain=${toChainId}&fromToken=${request.fromToken}&toToken=${request.toToken}&fromAmount=${request.amountInWei}&fromAddress=${request.userAddress}&slippage=${slipParam}`;
         const headers = {};
         if (key)
             headers['x-lifi-api-key'] = key;
         const res = await (0, httpClient_1.safeFetch)(url, {
             headers,
-            signal: context.abortSignal
+            signal: context.abortSignal,
+            retries: 0
         });
         if (!res.ok)
             throw new Error(`LI.FI API Error: ${await res.text()}`);
         const data = await res.json();
+        // LiFi can return HTTP 200 with an 'errors' array if a tool fails
+        if (data.errors && data.errors.length > 0) {
+            const err = data.errors[0];
+            throw new Error(`LI.FI route error (${err.code || 'UNKNOWN'}): ${err.message}`);
+        }
+        // transactionRequest may be null if LiFi found no executable route
+        if (!data.transactionRequest || !data.transactionRequest.to) {
+            throw new Error(`[LifiProvider] No valid transactionRequest returned — no executable route found`);
+        }
         return {
             provider: this.manifest.name,
             routeId: `lifi-${crypto_1.default.randomUUID()}`,