nyxora 26.7.4 → 26.7.5

package/CHANGELOG.md

@@ -4,6 +4,37 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepashangelog.com/en/1.0.0/),
 
+## [26.7.5]
+### Reasoning & Agent Engine Architecture
+- **Event-Driven Tool Execution**: Fully refactored the core agent loop (`osAgent.ts`) from a linear synchronous executor to a highly scalable, event-driven architecture using Lifecycle Hooks (`beforeToolCall`, `afterToolCall`). This completely decouples security guardrails and domain-specific logic from the core loop.
+- **Parallel Execution Concurrency**: Supercharged the agent's data gathering capabilities by upgrading the execution engine to support parallel processing (`Promise.all`), allowing multiple safe tools to run concurrently for massive speed improvements.
+- **Deferred Tool Resolution (MCP Ready)**: Built-in support for dynamic tool resolution, allowing the agent to request and execute external tools (e.g., via Model Context Protocol servers) on-the-fly even if they aren't loaded in the initial context.
+- **Partial Streaming Feedback**: Long-running tools can now stream partial updates (`"⏳ Processing..."`) to the user interface (Telegram/Dashboard) before the execution is fully complete, significantly enhancing UX and transparency.
+- **Advanced Guardrails**: The strict `Reasoning Gate` and `Web3 Fast Return` logic have been cleanly migrated into standalone middleware hooks, ensuring the main executor remains agnostic and maintainable.
+- **Dynamic Reasoning Mapper**: Injected seamless support for `reasoning_effort` across the entire Unified Mapper API, making it universally compatible with both OpenAI and OpenRouter native reasoning models.
+- **UX Sanitizer**: Implemented intelligent regex filtering to intercept and strip raw LLM `<think>` tags before they are broadcast to user-facing channels, keeping chat interfaces clean and elegant.
+
+### UI/UX & Design System Overhaul
+- **Modern UI Aesthetic**: Executed a comprehensive overhaul of the dashboard interface. Introduced advanced glassmorphism (`backdrop-filter: blur(20px)`) to the sidebar, softened structural corners (`border-radius: 18px`), and applied modern micro-animations and subtle drop-shadows across chat bubbles and input forms.
+- **Color Harmony & Contrast**: Refined the Dark Mode palette by shifting the primary accent color to a sleek Cyan (`#32ADE6`). Adjusted typography across UI pills (Network Selectors, Trending Tokens) from harsh contrast to a harmonious, translucent off-white (`rgba(255, 255, 255, 0.85)`) for optimal readability without eye strain.
+- **Chat Experience**: Redesigned the chat bubbles to distinctly separate user and agent messages using vibrant colored backgrounds for the user and elegant dark-glass styling for the agent, significantly improving spatial distinction.
+
+### Native Channel Engine (Omni-Channel Integration)
+- **Massive Architecture Overhaul**: Replaced the legacy hardcoded Telegram/Discord gateway with a highly scalable `ChannelManager`. Nyxora now natively and dynamically supports 19 distinct messaging platforms without requiring external sidecars.
+- **Dynamic CLI Configuration**: Overhauled `setup.ts` to dynamically detect and register available channels, allowing users to select and configure credentials seamlessly via `nyxora start`.
+- **19 Native SDK Implementations**: Successfully integrated and compiled native event listeners, Webhooks, and Socket Modes for WhatsApp (Baileys), Slack (Bolt Socket Mode), LINE, Microsoft Teams, Mattermost, Matrix, Google Chat, Synology, Nextcloud, Zalo, Twitch, iMessage, IRC, QQ Bot, Nostr, SMS, and Voice.
+
+### Playbook Ecosystem & Automation
+- **Playbook Recorder (Auto-Learn)**: Introduced a powerful Auto-Learn capability (CRITICAL RULE 7) allowing the OS Agent to dynamically record terminal workflows, abstract them into markdown instructions, and autonomously generate new reusable SOPs (Playbooks) based on chat history.
+- **Skill Store Dashboard (Split-Pane UI)**: Built a brand-new native Skill Store interface in the dashboard (`Playbooks.tsx`), enabling users to browse, edit, and manage their local AI playbooks seamlessly via a modern split-pane editor without touching the terminal.
+
+### Features & Architecture
+- **Self-Learning & Continuous Improvement**: Transformed Nyxora into a continuously evolving AI. The OS Agent (`osAgent.ts`) now natively injects narrative profiles (`MEMORY.md` and `USER.md`) directly into the system prompt at the start of every session.
+- **Asynchronous Background Review**: Engineered a non-blocking background auditor (`triggerBackgroundReview`) that executes silently after every interaction. The agent uses LangChain to evaluate recent conversations, autonomously identifying user preferences, extracting reusable workflows, and dynamically creating or patching its own skills (`skill_manager.py`) without user intervention.
+
+### Bug Fixes & Improvements
+- **Streaming UI Text Duplication & Glitch Fix**: Resolved a critical issue in the multi-turn streaming architecture where LLM "thought process" text (generated before a tool call) would leak and concatenate with the final answer on Telegram. Implemented a robust `[CLEAR_STREAM]` control signal that gracefully resets the message draft and displays a universal `⏳ Processing...` placeholder, completely eradicating message bubble collapse and visual jitter during tool execution.
+
 ## [26.7.4]
 ### Features & Architecture
 - **Cognitive Critic Engine Enhancements (Staleness Detection)**: Added a multilingual time-sensitive detection rule to the Critic Engine (`critic.py`). By injecting the current UTC datetime, the Critic now explicitly flags answers containing time-sensitive keywords (e.g., "today", "kemarin", "now") if they rely on stale training memory rather than fresh tool execution.

package/README.md

@@ -72,7 +72,7 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 
 ### Advanced Security Architecture
 *   **🛡️ On-Chain AI Kill-Switch**: Nyxora is governed by a Base Smart Contract (`NyxoraAgentRegistry`). Users have absolute cryptographic power to instantly paralyze the AI's on-chain execution if compromised, solving the Web3 AI safety dilemma. [Read more about our Base Architecture](https://nyxoraai.github.io/Nyxora/smart-contract)
-*   **4-Tier IPC Architecture**: Nyxora is split into isolated processes: **Core** (Node.js LLM Runtime), **ML Engine** (Python Cognitive Sidecar on port 8000), **Policy Engine** (Guardrails on port 3001), and **Signer Vault** (Isolated Key Manager on Unix Sockets).
+*   **6-Tier Hybrid Architecture**: Nyxora is split into isolated microservices: **Dashboard** (Port 5173), **MCP Server** (Port 3001), **Core LLM** (Port 3000), **ML Engine** (Python Sidecar on Port 8000), **Policy Engine** (Unix Socket), and **Signer Vault** (Unix Socket).
 *   **DeFi & Market Configuration BYOK & UI Masking**: All aggregator, provider, and oracle API keys are strictly isolated via a Bring Your Own Keys (BYOK) architecture into heavily guarded `~/.nyxora/defi_keys.yaml` and `~/.nyxora/market_keys.yaml` files. The local web Dashboard masks these injected secrets using `***********` and `IS_SET` censorship, completely neutralizing malicious browser extensions from exfiltrating your keys.
 *   **Approval Replay Protection (Nonce Guard)**: Transactions requested by the AI are drafted as hashes and signed with a randomized 16-byte Nonce. The `/api/transactions/:id/approve` endpoint strictly enforces Nonce matching to completely eliminate double-spending and Replay Attacks.
 *   **Native Asset Parameter Tampering Protection**: The internal cryptographic HMAC signature rigorously binds `toAddress`, `txData`, and `valueWei`, rendering the system mathematically immune to Native Token (ETH/BNB) destination or amount hijacking via Indirect Prompt Injections.
@@ -121,15 +121,54 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 
 ## 📐 Architecture Workflow
 
-The following diagram illustrates Nyxora's **4-Tier Hybrid Architecture**, showing the isolated communication channels (REST API and Unix Socket).
-
-![Architecture Workflow](https://raw.githubusercontent.com/perasyudha/Nyxora/main/assets/architecture.svg)
+The following diagram illustrates Nyxora's **6-Tier Hybrid Architecture**, showing the isolated communication channels across the ecosystem.
+
+```text
++-------------------------------------------------------------+
+|                     Nyxora 6-Tier Architecture              |
++-------------------------------------------------------------+
+
+    [ User / External Client ]
+               |
+               v
++-----------------------------+       +-------------------------+
+|     Dashboard (UI)          |       |      MCP Server         |
+|        Port 5173            |       |       Port 3001         |
++-----------------------------+       +-------------------------+
+               |                                  |
+               +---------------+------------------+
+                               |
+                               v
+                    +--------------------+
+                    |   Core LLM Runtime | <--- (NLP Parsing, Routing,
+                    |      Port 3000     |       Agent Logic)
+                    +--------------------+
+                      ^                |
+       (RAG & Math)   |                |  (Draft Transaction)
+                      v                v
++-------------------------+   +-------------------------------+
+|       ML Engine         |   |    Policy Engine (Guard)      |
+|       Port 8000         |   |  Unix Socket (IPC) / Loopback |
++-------------------------+   +-------------------------------+
+                                               |
+                                               | (Approved Payload)
+                                               v
+                              +-------------------------------+
+                              |    Signer Vault (Safe)        |
+                              |       Unix Socket (IPC)       |
+                              +-------------------------------+
+                                               |
+                                               v
+                                      [ Blockchain RPC ]
+```
 
-*Nyxora separates its duties into 4 independent layers for absolute security and cognitive depth:*
-1. **🧠 Core (The AI Brain)**: The Node.js intelligent assistant that strategizes and plans transactions, but **never** holds your funds.
-2. **🧬 ML Engine (Cognitive Sidecar)**: A local Python/FastAPI sidecar running LangChain and HuggingFace models for hyper-fast Semantic RAG memory and Pandas-based technical market analysis.
-3. **🛡️ Policy Engine (The Guard)**: The security guard that verifies the Brain's plans. If the AI attempts to send funds exceeding your set limits, this engine automatically blocks it.
-4. **🔒 Signer Vault (The Safe)**: The offline vault where your Private Keys **and highly sensitive 3rd-party tokens (e.g., Google Workspace OAuth)** are securely locked natively in your OS Keyring. It only signs transactions after they pass all rigorous security checks.
+*Nyxora separates its duties into 6 independent layers for absolute security and cognitive depth:*
+1. **🖥️ Dashboard (UI)**: A premium local React interface for real-time monitoring and conversational execution.
+2. **🔌 MCP Server (Context Provider)**: An open standard interface to connect Nyxora with external AI environments like Claude Desktop natively.
+3. **🧠 Core (The AI Brain)**: The Node.js intelligent assistant that strategizes and plans transactions, but **never** holds your funds.
+4. **🧬 ML Engine (Cognitive Sidecar)**: A local Python/FastAPI sidecar running LangChain and HuggingFace models for hyper-fast Semantic RAG memory and Pandas-based technical market analysis.
+5. **🛡️ Policy Engine (The Guard)**: The security guard that verifies the Brain's plans. If the AI attempts to send funds exceeding your set limits, this engine automatically blocks it.
+6. **🔒 Signer Vault (The Safe)**: The offline vault where your Private Keys **and highly sensitive 3rd-party tokens (e.g., Google Workspace OAuth)** are securely locked natively in your OS Keyring. It only signs transactions after they pass all rigorous security checks.
 
 ### Web3 Separation of Concerns (Zero-Trust Routing)
 Within the AI Brain, the Web3 codebase is strictly divided to prevent the LLM from hallucinating or maliciously manipulating low-level routing paths:

package/dist/launcher.js

@@ -141,7 +141,9 @@ setTimeout(() => {
         // Spawn ML Engine (Python Sidecar)
         const pythonPath = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'ml-engine', 'venv', 'bin', 'python');
         if (fs_1.default.existsSync(pythonPath)) {
-            const mlDir = path_1.default.join(__dirnameResolved, 'packages', 'ml-engine');
+            let mlDir = path_1.default.join(__dirnameResolved, 'packages', 'ml-engine');
+            if (!fs_1.default.existsSync(mlDir))
+                mlDir = path_1.default.join(__dirnameResolved, '..', 'packages', 'ml-engine');
             const mlArgs = ['-m', 'uvicorn', 'main:app', '--host', '127.0.0.1', '--port', '8000'];
             const mlEngine = spawnService('ML Engine', pythonPath, mlArgs, env, false, mlDir);
             children.push(mlEngine);
@@ -154,6 +156,32 @@ setTimeout(() => {
             const args = process.argv.slice(2);
             const core = spawnService('Core', cmd, [...baseArgs, corePath, ...args], env, true);
             children.push(core);
+            // --- AUTO-TUNNEL (Cloudflare) ---
+            setTimeout(() => {
+                console.log('[Launcher] Starting Auto-Tunnel (Cloudflare) on port 3000...');
+                const cf = (0, child_process_1.spawn)('npx', ['cloudflared', 'tunnel', '--url', 'http://localhost:3000'], { env, shell: true });
+                children.push({
+                    kill: () => { try {
+                        process.kill(cf.pid, 'SIGTERM');
+                    }
+                    catch (e) { } },
+                    forceKill: () => { try {
+                        process.kill(cf.pid, 'SIGKILL');
+                    }
+                    catch (e) { } }
+                });
+                cf.stderr.on('data', (data) => {
+                    const msg = data.toString();
+                    // Extract the Cloudflare URL (e.g., https://xyz.trycloudflare.com)
+                    const match = msg.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
+                    if (match) {
+                        const url = match[0];
+                        console.log(`\n[Auto-Tunnel] Secure Public URL generated: ${url}\n`);
+                        fs_1.default.writeFileSync(path_1.default.join(nyxoraDir, 'public_url.txt'), url, 'utf8');
+                    }
+                    // Optionally print errors if they are real errors, but cloudflared logs everything to stderr
+                });
+            }, 3000);
         }, 1000);
     }, 1000);
 }, 1000);

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startBridgeWatcher = startBridgeWatcher;
 const transactionManager_1 = require("./transactionManager");
-const telegram_1 = require("../gateway/telegram");
+const telegram_1 = require("../channels/telegram");
 const parser_1 = require("../config/parser");
 // In a real production environment, this would use the @eth-optimism/sdk 
 // to fetch the Merkle Proof and call proveWithdrawalTransaction on L1.

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

@@ -39,7 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cronManager = void 0;
 const croner_1 = require("croner");
 const parser_1 = require("../config/parser");
-const telegram_1 = require("../gateway/telegram");
+const telegram_1 = require("../channels/telegram");
 const crypto_1 = require("crypto");
 const picocolors_1 = __importDefault(require("picocolors"));
 class CronManager {

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

@@ -11,6 +11,7 @@ class OpenAIAdapter {
         return {
             message: {
                 content: response.choices[0].message.content,
+                reasoning_content: response.choices[0].message.reasoning_content || null,
                 tool_calls: response.choices[0].message.tool_calls
             },
             usage: response.usage ? { total_tokens: response.usage.total_tokens } : undefined
@@ -20,6 +21,7 @@ class OpenAIAdapter {
         try {
             const streamRes = await this.client.chat.completions.create({ ...request, stream: true });
             let fullContent = '';
+            let reasoningContent = '';
             const toolCallsMap = {};
             for await (const chunk of streamRes) {
                 const delta = chunk.choices[0]?.delta;
@@ -27,6 +29,9 @@ class OpenAIAdapter {
                     fullContent += delta.content;
                     onChunk(delta.content);
                 }
+                if (delta?.reasoning_content) {
+                    reasoningContent += delta.reasoning_content;
+                }
                 if (delta?.tool_calls) {
                     for (const tc of delta.tool_calls) {
                         if (!toolCallsMap[tc.index]) {
@@ -47,6 +52,7 @@ class OpenAIAdapter {
             return {
                 message: {
                     content: fullContent || null,
+                    reasoning_content: reasoningContent || null,
                     tool_calls: toolCalls.length > 0 ? toolCalls : undefined
                 }
             };
@@ -55,6 +61,7 @@ class OpenAIAdapter {
             // Fallback to non-streaming if streaming fails
             const chatRes = await this.chat(request);
             if (chatRes.message.content) {
+                onChunk('[CLEAR_STREAM]');
                 onChunk(chatRes.message.content);
             }
             return chatRes;
@@ -149,11 +156,15 @@ class AnthropicAdapter {
             max_tokens: request.max_tokens || 4096
         });
         let contentStr = null;
+        let reasoningStr = null;
         let toolCalls = [];
         for (const block of response.content) {
             if (block.type === 'text') {
                 contentStr = (contentStr || '') + block.text;
             }
+            else if (block.type === 'thinking') {
+                reasoningStr = (reasoningStr || '') + block.thinking;
+            }
             else if (block.type === 'tool_use') {
                 toolCalls.push({
                     id: block.id,
@@ -168,6 +179,7 @@ class AnthropicAdapter {
         return {
             message: {
                 content: contentStr,
+                reasoning_content: reasoningStr,
                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined
             },
             usage: response.usage ? { total_tokens: response.usage.input_tokens + response.usage.output_tokens } : undefined
@@ -233,12 +245,16 @@ class AnthropicAdapter {
                 max_tokens: request.max_tokens || 4096
             });
             let fullContent = '';
+            let reasoningContent = '';
             const toolCalls = [];
             for await (const event of stream) {
                 if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
                     fullContent += event.delta.text;
                     onChunk(event.delta.text);
                 }
+                if (event.type === 'content_block_delta' && event.delta.type === 'thinking_delta') {
+                    reasoningContent += event.delta.thinking;
+                }
                 if (event.type === 'content_block_start' && event.content_block.type === 'tool_use') {
                     toolCalls.push({ id: event.content_block.id, type: 'function', function: { name: event.content_block.name, arguments: '' } });
                 }
@@ -248,10 +264,15 @@ class AnthropicAdapter {
                         last.function.arguments += event.delta.partial_json;
                 }
             }
-            return { message: { content: fullContent || null, tool_calls: toolCalls.length > 0 ? toolCalls : undefined } };
+            return { message: { content: fullContent || null, reasoning_content: reasoningContent || null, tool_calls: toolCalls.length > 0 ? toolCalls : undefined } };
         }
         catch {
-            return this.chat(request);
+            const chatRes = await this.chat(request);
+            if (chatRes.message.content) {
+                onChunk('[CLEAR_STREAM]');
+                onChunk(chatRes.message.content);
+            }
+            return chatRes;
         }
     }
 }
@@ -510,7 +531,12 @@ class GeminiAdapter {
             };
         }
         catch {
-            return this.chat(request);
+            const chatRes = await this.chat(request);
+            if (chatRes.message.content) {
+                onChunk('[CLEAR_STREAM]');
+                onChunk(chatRes.message.content);
+            }
+            return chatRes;
         }
     }
 }

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

@@ -82,7 +82,7 @@ class NyxDaemon {
                 }
             }
             catch (e) {
-                console.error(picocolors_1.default.red('[Nyx] Failed to process traits from Python'), traits);
+                console.error(picocolors_1.default.red('[Nyx] Failed to process traits from Python: ' + e.message), traits);
             }
         }
         catch (e) {