nyxora 26.7.8 → 26.7.9

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

@@ -68,7 +68,7 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
             const currentHistory = exports.logger.getHistory(sessionId);
             // P6: Compress history if conversation is too long
             const historyToUse = (0, contextSummarizer_1.needsCompression)(currentHistory)
-                ? await (0, contextSummarizer_1.compressHistory)(currentHistory)
+                ? await (0, contextSummarizer_1.compressHistory)(currentHistory, sessionId)
                 : currentHistory;
             const sanitizedHistory = sanitizeHistoryForLLM(historyToUse, activeTools, config.llm.provider);
             // P1: Inject scratchpad into system prompt for turns > 1
@@ -105,6 +105,7 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
             // --- LLM FALLBACK COMMAND PARSER (Minimax/Open-weight fix) ---
             if ((!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) && responseMessage.content) {
                 const fallbacks = [];
+                // 1. Slash commands (/swap amount="100")
                 const regex = /^\/([a-zA-Z0-9_]+)\s+(.*)$/gm;
                 let match;
                 while ((match = regex.exec(responseMessage.content)) !== null) {
@@ -133,9 +134,25 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
                         }
                     });
                 }
+                // 2. Markdown bash blocks (```bash ... ```)
+                const mdRegex = /```(?:bash|sh|zsh)?\n([\s\S]*?)```/g;
+                let mdMatch;
+                while ((mdMatch = mdRegex.exec(responseMessage.content)) !== null) {
+                    const bashCmd = mdMatch[1].trim();
+                    if (bashCmd) {
+                        fallbacks.push({
+                            id: 'call_fallback_' + Math.random().toString(36).substr(2, 9),
+                            type: 'function',
+                            function: {
+                                name: 'run_terminal_command',
+                                arguments: JSON.stringify({ command: bashCmd })
+                            }
+                        });
+                    }
+                }
                 if (fallbacks.length > 0) {
                     responseMessage.tool_calls = fallbacks;
-                    responseMessage.content = responseMessage.content.replace(/^\/[a-zA-Z0-9_]+\s+.*$/gm, '').trim();
+                    responseMessage.content = responseMessage.content.replace(/^\/[a-zA-Z0-9_]+\s+.*$/gm, '').replace(/```(?:bash|sh|zsh)?\n([\s\S]*?)```/g, '').trim();
                     console.log(picocolors_1.default.cyan(`[Fallback Parser] Intercepted ${fallbacks.length} raw text commands and converted to tool_calls.`));
                     // Update logger entry with the intercepted tool calls
                     exports.logger.addEntry({
@@ -145,17 +162,17 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
                     }, sessionId);
                 }
             }
-            // -----------------------------------------------------
+            // ---------------------------------------------------------------
             if (!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) {
-                return cleanedContent || 'No response generated.';
+                return cleanedContent || '⚠️ I encountered an issue processing your request. This can happen with very complex multi-step tasks. Please try rephrasing or breaking the request into smaller steps.';
             }
             let canFastReturnAll = true;
             let accumulatedResults = [];
-            // FIX: Removed send_telegram_file — only financial Web3 ops need fast-return
+            // FIX: Re-added send_telegram_file to prevent "typing" loop after file upload.
             const fastReturnTools = [
                 'transfer_token', 'transfer_native', 'swap_token', 'bridge_token',
                 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave',
-                'deposit_yield_vault', 'provide_liquidity_v3', 'confirm_pending_tx'
+                'deposit_yield_vault', 'provide_liquidity_v3', 'confirm_pending_tx', 'send_telegram_file'
             ];
             for (const _toolCall of responseMessage.tool_calls) {
                 const toolCall = _toolCall;
@@ -310,12 +327,17 @@ async function processWeb3IntentStream(input, onChunk, onProgress, sessionId) {
     const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
     try {
         let turnCount = 0;
+        let nudgeCount = 0;
         const MAX_TURNS = 20;
+        let thinkingPrefillRetries = 0; // Prefill-continuation retries for think-only silent stops
         let fullResponse = '';
         while (turnCount < MAX_TURNS) {
             turnCount++;
             const currentHistory = exports.logger.getHistory(sessionId);
-            const sanitizedHistory = sanitizeHistoryForLLM(currentHistory, activeTools, config.llm.provider);
+            const historyToUse = (0, contextSummarizer_1.needsCompression)(currentHistory)
+                ? await (0, contextSummarizer_1.compressHistory)(currentHistory, sessionId)
+                : currentHistory;
+            const sanitizedHistory = sanitizeHistoryForLLM(historyToUse, activeTools, config.llm.provider);
             // FIX: Use cached system prompt — no longer rebuilt every turn
             const messages = [
                 { role: 'system', content: cachedWeb3SystemPrompt },
@@ -346,27 +368,103 @@ async function processWeb3IntentStream(input, onChunk, onProgress, sessionId) {
                 tool_calls: responseMessage.tool_calls,
             }, sessionId);
             if (!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) {
-                let finalContent = responseMessage.content || 'No response generated.';
+                let finalContent = responseMessage.content || '';
                 finalContent = finalContent.replace(/<(think|thought|thinking|reasoning|analysis|reflection)[\s\S]*?<\/\1>\n?/gi, '').trim();
                 finalContent = finalContent.replace(/^\s*(?:\*\*)?(?:think|thought|thinking|reasoning|analysis|reflection)(?:\*\*)?\s*?\n[\s\S]*?\n\n/i, '').trim();
+                // Support global languages: English, Indonesian, Spanish, French, German filler words
+                const isConversationalFiller = finalContent.length > 0 && finalContent.length < 250 && /(wait|checking|executing|processing|give me a moment|let me check|one moment|hold on|tunggu|sebentar|lagi proses|lanjut cek|gue cek|aku cek|un momento|attendez|bitte warten)[\s\.\!a-z]*$/i.test(finalContent.trim());
+                if (finalContent === '' || isConversationalFiller) {
+                    const hasNativeReasoning = !!responseMessage.reasoning_content;
+                    const hasThinkTagInStream = /<(think|thought|thinking|reasoning)[\s\S]*?<\//i.test(streamedContent);
+                    const isThinkOnlyResponse = hasNativeReasoning || hasThinkTagInStream;
+                    // ── THINKING-PREFILL CONTINUATION ──
+                    if (isThinkOnlyResponse && thinkingPrefillRetries < 2) {
+                        thinkingPrefillRetries++;
+                        console.warn(`[Web3AgentStream] ⚠️ Think-only silent stop — prefilling to continue (${thinkingPrefillRetries}/2)...`);
+                        continue;
+                    }
+                    // ── NUDGE FALLBACK (after prefill exhaustion or truly empty) ──
+                    if (nudgeCount < 3) {
+                        nudgeCount++;
+                        const recentUserMsg = exports.logger.getHistory(sessionId)
+                            .filter((m) => m.role === 'user').slice(-1)[0]?.content || 'the user request';
+                        let nudgeContent;
+                        if (isThinkOnlyResponse) {
+                            console.warn(`[Web3AgentStream] ⚠️ Think-only prefill exhausted. System nudge (${nudgeCount}/3)...`);
+                            nudgeContent = `[SYSTEM NUDGE ${nudgeCount}/3 — SILENT STOP DETECTED]
+You completed your internal reasoning but produced NO output (no tool call, no text).
+This is a silent stop — it is not acceptable.
+
+Task: "${recentUserMsg.substring(0, 200)}"
+
+You MUST act RIGHT NOW. Do one of these:
+  A) Call the first required tool immediately (e.g., get_price, analyze_market, get_balance)
+  B) Output a final text answer
+
+Do NOT think again. Execute step 1 of the task NOW.`;
+                        }
+                        else {
+                            console.warn(`[Web3AgentStream] ⚠️ Empty or filler response. System nudge (${nudgeCount}/3)...`);
+                            nudgeContent = `[SYSTEM NUDGE ${nudgeCount}/3] Your last response was empty or contained conversational filler without tool calls. You MUST take action now.
+
+Task: "${recentUserMsg.substring(0, 200)}"
+
+Available tools: swap_token, get_portfolio, etc.
+You MUST either:
+  A) Call one or more tools, OR
+  B) Output a complete final text answer
+
+Do NOT output filler text like "Wait, I will check". Act now.`;
+                        }
+                        exports.logger.addEntry({
+                            role: 'system',
+                            content: nudgeContent
+                        }, sessionId);
+                        continue;
+                    }
+                    else {
+                        console.error('[Web3AgentStream] ❌ LLM failed to recover after prefill + 3 nudges. Aborting.');
+                        const reasoningContent = responseMessage.reasoning_content || '';
+                        if (reasoningContent && reasoningContent.length > 50) {
+                            console.warn('[Web3AgentStream] Using reasoning_content as fallback response.');
+                            finalContent = reasoningContent.replace(/<(think|thought|thinking)[\s\S]*?<\/\1>/gi, '').trim()
+                                || '⚠️ I encountered an issue processing your request. This can happen with very complex multi-step tasks. Please try rephrasing or breaking the request into smaller steps.';
+                        }
+                        else {
+                            finalContent = '⚠️ I encountered an issue processing your request. This can happen with very complex multi-step tasks. Please try rephrasing or breaking the request into smaller steps.';
+                        }
+                    }
+                }
+                // Reset prefill counter on successful response
+                thinkingPrefillRetries = 0;
                 fullResponse = finalContent;
                 break;
             }
             // Tool calls detected — pause stream visually and execute tools
             // BUG#1 FIX: Wipe turn-1 planning text. See osAgent.ts for full explanation.
-            onChunk('[TOOL_CALL_DETECTED]');
-            // FIX: Removed send_telegram_file — not a financial transaction
-            const fastReturnTools = ['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3', 'confirm_pending_tx'];
+            await onChunk('[TOOL_CALL_DETECTED]');
+            // FIX: Re-added send_telegram_file to prevent "typing" loop after file upload.
+            const fastReturnTools = ['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3', 'confirm_pending_tx', 'send_telegram_file'];
             let canFastReturnAll = true;
             const accumulatedResults = [];
-            for (const _toolCall of responseMessage.tool_calls) {
+            // Deduplicate identical tool calls to prevent double execution bugs
+            const uniqueToolCalls = [];
+            const seenToolCalls = new Set();
+            for (const tc of responseMessage.tool_calls) {
+                const sig = `${tc.function.name}:${tc.function.arguments}`;
+                if (!seenToolCalls.has(sig)) {
+                    seenToolCalls.add(sig);
+                    uniqueToolCalls.push(tc);
+                }
+            }
+            for (const _toolCall of uniqueToolCalls) {
                 const toolCall = _toolCall;
                 const toolName = toolCall.function.name;
                 let result = '';
                 let args = {};
                 console.log(picocolors_1.default.yellow(`[⚡ Tool Execution] AI is calling ${toolName}...`));
                 if (onProgress)
-                    onProgress(`_⚡ Running tool: ${toolName}..._`);
+                    onProgress(`⚡ Running tool: ${toolName}...`);
                 try {
                     let argStr = toolCall.function.arguments;
                     if (argStr && !argStr.trim().endsWith('}'))
@@ -402,11 +500,15 @@ async function processWeb3IntentStream(input, onChunk, onProgress, sessionId) {
                 if (!fastReturnTools.includes(toolName))
                     canFastReturnAll = false;
             }
+            await onChunk('[TOOL_CALL_FINISHED]');
             if (canFastReturnAll && accumulatedResults.length > 0) {
                 const finalContent = accumulatedResults.join('\n\n---\n\n');
-                exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
-                onChunk(finalContent);
-                fullResponse = finalContent;
+                const cleanContent = finalContent.replace(/\[SILENT_FAST_RETURN\] /g, '');
+                exports.logger.addEntry({ role: 'assistant', content: cleanContent }, sessionId);
+                if (!finalContent.includes('[SILENT_FAST_RETURN]')) {
+                    await onChunk(finalContent);
+                }
+                fullResponse = cleanContent;
                 break;
             }
         }

package/dist/packages/core/src/channels/telegram.js

@@ -124,7 +124,8 @@ function startTelegramBot() {
             return;
         });
         bot.command('clear', async (ctx) => {
-            reasoning_1.logger.clear(`telegram_${ctx.chat?.id}`);
+            const threadId = ctx.message?.message_thread_id ? `_${ctx.message.message_thread_id}` : '';
+            reasoning_1.logger.clear(`telegram_${ctx.chat?.id}${threadId}`);
             await ctx.reply("✅ AI memory has been cleared. Let's start a new chat!");
         });
         bot.command('reasoning', async (ctx) => {
@@ -203,17 +204,32 @@ function startTelegramBot() {
                     buffer = '⏳ Processing...';
                     finalContentAlreadyStreamed = false;
                 }
-                else if (chunk === '[TOOL_CALL_DETECTED]') {
-                    // BUG#1 FIX: LLM made a tool call — wipe turn-1 planning/thinking text from buffer.
-                    // The LLM often generates "chain-of-thought" text before calling a tool (e.g. "Let me
-                    // check the data first..."). This should NOT be shown to users. We reset the buffer to
-                    // a clean progress indicator, preserving progressMsgId so the same message gets reused.
-                    buffer = '⏳ Processing...';
+                else if (chunk === '[TOOL_CALL_DETECTED]' || chunk === '[TOOL_CALL_FINISHED]') {
+                    // Hermes-Agent tool boundary: Finalize the current message synchronously to avoid race conditions.
+                    const htmlToSave = formatToTelegramHTML(buffer);
+                    const msgIdToSave = progressMsgId;
+                    progressMsgId = null;
+                    buffer = '';
                     finalContentAlreadyStreamed = false;
-                    scheduleEdit(); // Update Telegram immediately to show clean state
+                    if (pendingEdit) {
+                        clearTimeout(pendingEdit);
+                        pendingEdit = null;
+                    }
+                    if (msgIdToSave && htmlToSave) {
+                        await ctx.api.editMessageText(ctx.chat.id, msgIdToSave, htmlToSave, { parse_mode: 'HTML' }).catch(() => { });
+                    }
+                    else if (!msgIdToSave && htmlToSave) {
+                        await ctx.reply(htmlToSave, { parse_mode: 'HTML', reply_parameters: { message_id: ctx.message.message_id } }).catch(() => { });
+                    }
+                    return;
                 }
                 else {
-                    buffer += chunk;
+                    if (buffer === '⏳ Processing...') {
+                        buffer = chunk;
+                    }
+                    else {
+                        buffer += chunk;
+                    }
                 }
                 scheduleEdit();
             };
@@ -222,7 +238,9 @@ function startTelegramBot() {
                 scheduleEdit();
             };
             try {
-                const response = await (0, reasoning_1.processUserInputStream)(text, onChunk, onProgress, `telegram_${ctx.chat?.id}`);
+                const threadId = ctx.message.message_thread_id ? `_${ctx.message.message_thread_id}` : '';
+                const sessionId = `telegram_${ctx.chat?.id}${threadId}`;
+                const response = await (0, reasoning_1.processUserInputStream)(text, onChunk, onProgress, sessionId);
                 isFinalized = true;
                 if (pendingEdit) {
                     clearTimeout(pendingEdit);
@@ -394,8 +412,30 @@ function startTelegramBot() {
                     if (chunk === '[CLEAR_STREAM]') {
                         buffer = '⏳ Processing...';
                     }
+                    else if (chunk === '[TOOL_CALL_DETECTED]' || chunk === '[TOOL_CALL_FINISHED]') {
+                        const htmlToSave = formatToTelegramHTML(buffer);
+                        const msgIdToSave = progressMsgId;
+                        progressMsgId = null;
+                        buffer = '';
+                        if (pendingEdit) {
+                            clearTimeout(pendingEdit);
+                            pendingEdit = null;
+                        }
+                        if (msgIdToSave && htmlToSave) {
+                            await ctx.api.editMessageText(ctx.chat.id, msgIdToSave, htmlToSave, { parse_mode: 'HTML' }).catch(() => { });
+                        }
+                        else if (!msgIdToSave && htmlToSave) {
+                            await ctx.reply(htmlToSave, { parse_mode: 'HTML', reply_parameters: { message_id: ctx.message.message_id } }).catch(() => { });
+                        }
+                        return;
+                    }
                     else {
-                        buffer += chunk;
+                        if (buffer === '⏳ Processing...') {
+                            buffer = chunk;
+                        }
+                        else {
+                            buffer += chunk;
+                        }
                     }
                     scheduleEdit();
                 };
@@ -404,7 +444,10 @@ function startTelegramBot() {
                     scheduleEdit();
                 };
                 try {
-                    const response = await (0, reasoning_1.processUserInputStream)(simulatedText, onChunk, onProgress, `telegram_${ctx.chat.id}`);
+                    const msg = ctx.callbackQuery.message;
+                    const threadId = msg?.message_thread_id ? `_${msg.message_thread_id}` : '';
+                    const sessionId = `telegram_${ctx.chat.id}${threadId}`;
+                    const response = await (0, reasoning_1.processUserInputStream)(simulatedText, onChunk, onProgress, sessionId);
                     isFinalized = true;
                     if (pendingEdit) {
                         clearTimeout(pendingEdit);
@@ -485,7 +528,9 @@ function startTelegramBot() {
                     }
                     catch { }
                 };
-                const response = await (0, reasoning_1.processUserInput)(prompt, 'user', onProgress, `telegram_${ctx.chat?.id}`);
+                const threadId = ctx.message?.message_thread_id ? `_${ctx.message.message_thread_id}` : '';
+                const sessionId = `telegram_${ctx.chat?.id}${threadId}`;
+                const response = await (0, reasoning_1.processUserInput)(prompt, 'user', onProgress, sessionId);
                 if (progressMsgId) {
                     await ctx.api.deleteMessage(ctx.chat.id, progressMsgId).catch(() => { });
                 }
@@ -528,7 +573,9 @@ function startTelegramBot() {
                     }
                     catch { }
                 };
-                const response = await (0, reasoning_1.processUserInput)(prompt, 'user', onProgress, `telegram_${ctx.chat?.id}`);
+                const threadId = ctx.message?.message_thread_id ? `_${ctx.message.message_thread_id}` : '';
+                const sessionId = `telegram_${ctx.chat?.id}${threadId}`;
+                const response = await (0, reasoning_1.processUserInput)(prompt, 'user', onProgress, sessionId);
                 if (progressMsgId) {
                     await ctx.api.deleteMessage(ctx.chat.id, progressMsgId).catch(() => { });
                 }
@@ -584,8 +631,16 @@ async function sendTelegramDocument(absolutePath) {
         return `[Error] File not found: ${absolutePath}`;
     try {
         const file = new grammy_1.InputFile(absolutePath);
-        await globalBotInstance.api.sendDocument(chatId, file);
-        return `Success! File has been uploaded directly to the Telegram chat.`;
+        // Wait for the stream to flush the "⚡ Running tool..." message so the file appears after it
+        await new Promise(r => setTimeout(r, 1500));
+        const ext = absolutePath.toLowerCase();
+        if (ext.endsWith('.png') || ext.endsWith('.jpg') || ext.endsWith('.jpeg') || ext.endsWith('.gif') || ext.endsWith('.webp')) {
+            await globalBotInstance.api.sendPhoto(chatId, file);
+        }
+        else {
+            await globalBotInstance.api.sendDocument(chatId, file);
+        }
+        return `[SILENT_FAST_RETURN] Success! File has been uploaded directly to the Telegram chat.`;
     }
     catch (err) {
         return `[Error] Failed to upload document to Telegram: ${err.message}`;

package/dist/packages/core/src/channels/whatsappAdapter.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.adapter = exports.WhatsappAdapter = void 0;
 class WhatsappAdapter {
@@ -42,18 +9,20 @@ class WhatsappAdapter {
         console.log(`[WhatsApp] Initializing...`);
     }
     async start() {
-        // Lazy import — baileys is an optional dependency not bundled with Nyxora core.
-        // Install it separately if you want WhatsApp support: npm install -g baileys
+        // Lazy require — baileys is a runtime-optional dependency not bundled with Nyxora.
+        // Install separately if you want WhatsApp support: npm install baileys
+        // Using require() instead of import() to bypass TypeScript type resolution for optional packages.
         let makeWASocket, useMultiFileAuthState, DisconnectReason;
         try {
-            const baileys = await Promise.resolve().then(() => __importStar(require('baileys')));
+            // @ts-ignore — intentional: baileys is optional and may not be installed
+            const baileys = require('baileys');
             makeWASocket = baileys.default || baileys;
             useMultiFileAuthState = baileys.useMultiFileAuthState;
             DisconnectReason = baileys.DisconnectReason;
         }
         catch (e) {
             console.error('[WhatsApp] Cannot start: missing optional dependency "baileys".');
-            console.error('[WhatsApp] Install it with: npm install -g baileys');
+            console.error('[WhatsApp] Install it with: npm install baileys');
             return;
         }
         const { state, saveCreds } = await useMultiFileAuthState('whatsapp_auth_info');

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

@@ -66,7 +66,7 @@ const nyxDaemon_1 = require("../agent/nyxDaemon");
 (0, googleAuthModule_1.initGoogleAuth)();
 // Start Background Nyx Daemon
 nyxDaemon_1.nyxDaemon.start();
-// Synchronize playbooks using Smart Sync Engine (Hermes Parity)
+// Synchronize playbooks using Smart Sync Engine
 (0, playbookManager_1.ensurePlaybookDir)();
 // Synchronize all active skills to config.yaml on startup
 (0, skillManager_1.syncAllSkillsToConfig)();

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

@@ -337,14 +337,17 @@ Provider: ${config.llm.provider}`;
         { value: 'dashboard', label: 'Local Web Dashboard', hint: 'enabled by default' },
     ];
     try {
-        const { channelManager } = require('../channels/index');
+        const { channelManager, registerAllAdapters } = require('../channels/index');
+        await registerAllAdapters();
         channelManager.getAllAdapters().forEach((adapter) => {
             if (adapter.id !== 'telegram' && adapter.id !== 'discord') {
                 channelOptions.push({ value: adapter.id, label: adapter.name, hint: 'New Integration' });
             }
         });
     }
-    catch (err) { }
+    catch (err) {
+        console.error('Error loading dynamic channels:', err);
+    }
     const activeChannels = await (0, prompts_1.multiselect)({
         message: '💬 Select Integration Channels to enable:',
         options: channelOptions,
@@ -362,6 +365,7 @@ Provider: ${config.llm.provider}`;
             options: [
                 { value: 'tavily', label: 'Tavily Search (Built for AI - 1000 free/mo)' },
                 { value: 'brave', label: 'Brave Search (Privacy focused - 2000 free/mo)' },
+                { value: 'serpapi', label: 'SerpApi (Google Search - 100 free/mo)' },
                 { value: 'duckduckgo', label: 'DuckDuckGo (Free & Built-in)' },
             ],
         });
@@ -369,7 +373,7 @@ Provider: ${config.llm.provider}`;
             return process.exit(0);
         if (searchProvider !== 'duckduckgo') {
             searchApiKey = (await (0, prompts_1.password)({
-                message: `Enter API Key for ${searchProvider} (Get it free at ${searchProvider === 'tavily' ? 'tavily.com' : 'search.brave.com'}):`,
+                message: `Enter API Key for ${searchProvider} (Get it free at ${searchProvider === 'tavily' ? 'tavily.com' : searchProvider === 'serpapi' ? 'serpapi.com' : 'search.brave.com'}):`,
             }));
             if ((0, prompts_1.isCancel)(searchApiKey))
                 return process.exit(0);
@@ -504,6 +508,8 @@ Provider: ${config.llm.provider}`;
                 newApiKeys.tavily_key = searchApiKey;
             if (searchProvider === 'brave')
                 newApiKeys.brave_key = searchApiKey;
+            if (searchProvider === 'serpapi')
+                newApiKeys.serpapi_key = searchApiKey;
         }
     }
     else {

package/dist/packages/core/src/plugin/PluginManager.js

@@ -26,7 +26,21 @@ class PluginManager {
     getAllToolDefinitions() {
         const pluginTools = this.plugins.flatMap(p => p.tools);
         const agentTools = this.agentSkills.getToolSchemas();
-        return [...pluginTools, ...agentTools];
+        const allTools = [...pluginTools, ...agentTools];
+        const uniqueTools = [];
+        const seenNames = new Set();
+        for (const t of allTools) {
+            if (t?.function?.name) {
+                if (!seenNames.has(t.function.name)) {
+                    seenNames.add(t.function.name);
+                    uniqueTools.push(t);
+                }
+            }
+            else {
+                uniqueTools.push(t);
+            }
+        }
+        return uniqueTools;
     }
     async triggerBeforeHooks(toolName, args, context) {
         for (const hook of this.hooks) {

package/dist/packages/core/src/system/plugins/SystemWorkspacePlugin.js

@@ -10,6 +10,7 @@ const createCognitiveSkill_1 = require("../skills/createCognitiveSkill");
 const playbookManager_1 = require("../skills/playbookManager");
 const fileDownloader_1 = require("../skills/fileDownloader");
 const analyzeImage_1 = require("../skills/analyzeImage");
+const generateImage_1 = require("../skills/generateImage");
 const telegramUpload_1 = require("../skills/telegramUpload");
 class SystemWorkspacePlugin {
     name = 'SystemWorkspacePlugin';
@@ -26,6 +27,7 @@ class SystemWorkspacePlugin {
         playbookManager_1.readPlaybookToolDefinition,
         fileDownloader_1.generateDownloadLinkToolDefinition,
         analyzeImage_1.analyzeLocalImageToolDefinition,
+        generateImage_1.generateImageToolDefinition,
         telegramUpload_1.sendTelegramFileToolDefinition
     ];
     handlers = {
@@ -59,6 +61,9 @@ class SystemWorkspacePlugin {
         ['analyze_local_image']: async (args) => {
             return await (0, analyzeImage_1.analyzeLocalImage)(args.imagePath, args.prompt);
         },
+        ['generate_image']: async (args) => {
+            return await (0, generateImage_1.generateImage)(args.prompt);
+        },
         ['send_telegram_file']: async (args) => {
             return await (0, telegramUpload_1.sendTelegramFile)(args.absolutePath);
         }

package/dist/packages/core/src/system/skills/analyzeImage.js

@@ -34,13 +34,17 @@ async function analyzeLocalImage(imagePath, prompt) {
         return `[Error] Image file not found at path: ${imagePath}`;
     }
     try {
-        const { GoogleGenAI } = require('@google/genai');
+        const { GoogleGenerativeAI } = require('@google/generative-ai');
         const keys = await (0, parser_1.loadApiKeys)();
         const geminiKey = keys['gemini_key'];
         if (!geminiKey) {
             return `[Security Error] No gemini_key found in the vault. Please run 'nyxora set-key gemini' first.`;
         }
-        const ai = new GoogleGenAI({ apiKey: geminiKey });
+        const genAI = new GoogleGenerativeAI(geminiKey);
+        const model = genAI.getGenerativeModel({
+            model: 'gemini-2.5-flash',
+            generationConfig: { temperature: 0.1 }
+        });
         // Read file and determine mime type
         const buffer = fs_1.default.readFileSync(imagePath);
         const base64Data = buffer.toString('base64');
@@ -54,27 +58,16 @@ async function analyzeLocalImage(imagePath, prompt) {
             mimeType = 'image/heic';
         else if (ext === '.heif')
             mimeType = 'image/heif';
-        const response = await ai.models.generateContent({
-            model: 'gemini-2.5-flash',
-            contents: [
-                {
-                    role: 'user',
-                    parts: [
-                        { text: prompt },
-                        {
-                            inlineData: {
-                                data: base64Data,
-                                mimeType: mimeType
-                            }
-                        }
-                    ]
+        const response = await model.generateContent([
+            prompt,
+            {
+                inlineData: {
+                    data: base64Data,
+                    mimeType: mimeType
                 }
-            ],
-            config: {
-                temperature: 0.1
             }
-        });
-        return response.text || "[Error] No content generated.";
+        ]);
+        return response.response.text() || "[Error] No content generated.";
     }
     catch (error) {
         return `[System Error] Failed to analyze image: ${error.message}`;

package/dist/packages/core/src/system/skills/generateImage.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImageToolDefinition = void 0;
+exports.generateImage = generateImage;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const openai_1 = require("openai");
+const parser_1 = require("../../config/parser");
+exports.generateImageToolDefinition = {
+    type: 'function',
+    function: {
+        name: 'generate_image',
+        description: 'Generates an image using OpenAI DALL-E 3 based on a text prompt. The image is downloaded locally and the absolute file path is returned.',
+        parameters: {
+            type: 'object',
+            properties: {
+                prompt: {
+                    type: 'string',
+                    description: 'A highly detailed text prompt describing the image you want to generate.'
+                }
+            },
+            required: ['prompt']
+        }
+    }
+};
+async function generateImage(prompt) {
+    try {
+        const keys = await (0, parser_1.loadApiKeys)();
+        const openAIKey = keys['openai_key'];
+        if (!openAIKey) {
+            return `[Security Error] No openai_key found in the vault. Please run 'nyxora set-key openai' first.`;
+        }
+        const openai = new openai_1.OpenAI({ apiKey: openAIKey });
+        const response = await openai.images.generate({
+            model: "dall-e-3",
+            prompt: prompt,
+            n: 1,
+            size: "1024x1024",
+        });
+        const imageUrl = response.data[0].url;
+        if (!imageUrl) {
+            return `[Error] Failed to get image URL from OpenAI.`;
+        }
+        const res = await fetch(imageUrl);
+        const buffer = await res.arrayBuffer();
+        const imagesDir = path_1.default.join(os_1.default.homedir(), '.nyxora', 'images');
+        if (!fs_1.default.existsSync(imagesDir)) {
+            fs_1.default.mkdirSync(imagesDir, { recursive: true });
+        }
+        const safeName = prompt.substring(0, 30).replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+        const filename = `dalle-${Date.now()}-${safeName}.png`;
+        const localFilePath = path_1.default.join(imagesDir, filename);
+        fs_1.default.writeFileSync(localFilePath, Buffer.from(buffer));
+        return `Success! Image generated and saved locally at: ${localFilePath}`;
+    }
+    catch (error) {
+        return `[System Error] Failed to generate image: ${error.message}`;
+    }
+}