nyxora 26.7.4 → 26.7.8

package/CHANGELOG.md

@@ -4,6 +4,70 @@ 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.8]
+### Bug Fixes — Global Compatibility & Dashboard Crash
+
+- **Dashboard Not Accessible via `nyxora dashboard` (Critical Fix)**: Resolved a crash-on-startup bug where the entire Core gateway process would exit with code `1` before binding to port 3000, making `http://localhost:3000` unreachable. Root cause: `channels/index.ts` performed static top-level imports of `baileys`, `@slack/bolt`, and `@line/bot-sdk` — packages that are **not listed in `package.json` dependencies** and therefore not installed on global npm users' machines. Resolved by refactoring `channels/index.ts` into a `registerAllAdapters()` async function that uses dynamic `import()` with `MODULE_NOT_FOUND` error handling. Missing adapters now log a clear warning and are skipped instead of crashing the process.
+- **WhatsApp Adapter Lazy Load**: Migrated `whatsappAdapter.ts` from a static `import makeWASocket from 'baileys'` to a lazy `await import('baileys')` inside `start()`, with a graceful error and install instructions if `baileys` is absent.
+- **Slack Adapter Lazy Load**: Migrated `slackAdapter.ts` `@slack/bolt` import to lazy initialization inside `start()`.
+- **LINE Adapter Lazy Load**: Migrated `lineAdapter.ts` `@line/bot-sdk` import to lazy initialization inside `start()`.
+
+### Bug Fixes — Windows & Cross-Platform Compatibility
+
+- **Unix Socket Crash on Windows** (`ENOENT`/`ENOTSUP`): Replaced hardcoded Unix Domain Socket (`/tmp/nyxora-signer.sock`) in `signer/server.ts` with a cross-platform IPC strategy. On Windows, the signer now listens on TCP `127.0.0.1:3002`; Unix/Mac keeps the existing UDS path for security.
+- **Policy Engine Cross-Platform IPC**: Refactored all Signer proxy calls in `policy/server.ts` into a unified `signerRequestOptions()` helper that automatically selects Unix socket (Linux/Mac) or TCP (Windows). The optional UDS IPC server is now skipped entirely on Windows.
+- **vaultClient TCP Fallback**: Refactored `vaultClient.ts` with a `getPolicyOptions()` helper — on Windows, all Policy Engine requests use TCP; on Linux/Mac, Unix socket is preferred if available with automatic TCP fallback.
+- **Python Path on Windows**: Launcher now resolves the ML Engine Python executable to `venv/Scripts/python.exe` on Windows instead of `venv/bin/python`, preventing silent "Python not found" at startup.
+- **`pkill` Skipped on Windows**: Graceful shutdown in `launcher.ts` now guards `pkill -f ts-node` and `pkill -f uvicorn` behind a `process.platform !== 'win32'` check.
+- **Unix Socket Doctor Checks Skipped on Windows**: `nyxora doctor` now conditionally skips UDS socket health checks on Windows where they are not applicable.
+
+### Improvements — Configuration & Telemetry
+
+- **Cloudflare Tunnel Configurable**: Cloudflare auto-tunnel can now be disabled by setting `cloudflare_tunnel: false` in `~/.nyxora/config/config.yaml`. Previously it always launched unconditionally.
+- **ML Engine Health Check in `nyxora doctor`**: Added a dedicated check (#7) that pings `http://127.0.0.1:8000/health` to detect if the Python ML Engine sidecar is running. When daemon is stopped, it verifies the venv is installed and guides with `nyxora setup`.
+- **Node.js Version Enforcement**: Added `"engines": { "node": ">=22.0.0" }` to `package.json`. npm will now warn users attempting to install on incompatible Node.js versions instead of silently installing and crashing at runtime.
+- **Locale-Neutral System Prompt**: Replaced Indonesian-specific examples (`"cek saldo gue dirupiahin"`, `"fiat/rupiah"`) in `promptBuilder.ts` with multilingual examples (`"0.5 BTC in EUR"`, `"convert 100 SOL to JPY"`) to align with global user base.
+- **English-Only Source Code**: Translated the remaining Indonesian comment in `nyxDaemon.ts` (`// Kirim riwayat percakapan...`) to English for open-source contributor clarity.
+
+## [26.7.6]
+### Features & Architecture
+- **ML Engine Custom Provider Support**: Fixed a `500 Internal Server Error` in the Python ML Engine by explicitly supporting the `custom` and `openrouter` providers and gracefully handling empty API keys with a local fallback, ensuring robust execution for cognitive reasoning and RAG memory tasks.
+
+### Bug Fixes & Dashboard
+- **Dashboard Overview Key Detection**: Resolved a UI bug in the Dashboard Overview where custom and proxy providers (`custom_provider_key`, `9router_key`) incorrectly rendered as "Missing Key". The status engine now dynamically queries the exact credential mapping for off-standard providers.
+- **LLM Configuration Persistence Bug**: Fixed a configuration merging flaw in `Settings.tsx` where switching away from a `custom_provider` left the old `base_url` intact in the persistent payload. This previously caused subsequent standard LLM providers (e.g., OpenAI) to silently inherit the custom URL and crash. The dashboard now cleanly purges the `base_url` state upon provider transitions.
+
+## [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,50 @@ 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).
+The following diagram illustrates Nyxora's **6-Tier Hybrid Architecture**, showing the isolated communication channels across the ecosystem.
 
-![Architecture Workflow](https://raw.githubusercontent.com/perasyudha/Nyxora/main/assets/architecture.svg)
+```mermaid
+graph TD
+    classDef default fill:#1E1E2E,stroke:#4C4F69,stroke-width:2px,color:#CDD6F4;
+    classDef external fill:#11111B,stroke:#F38BA8,stroke-width:2px,color:#F38BA8,stroke-dasharray: 5 5;
+    classDef ui fill:#89B4FA,stroke:#1E1E2E,stroke-width:2px,color:#11111B;
+    classDef core fill:#A6E3A1,stroke:#1E1E2E,stroke-width:2px,color:#11111B;
+    classDef policy fill:#F9E2AF,stroke:#1E1E2E,stroke-width:2px,color:#11111B;
+    classDef signer fill:#F38BA8,stroke:#1E1E2E,stroke-width:2px,color:#11111B;
+    classDef blockchain fill:#CBA6F7,stroke:#1E1E2E,stroke-width:2px,color:#11111B;
 
-*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.
+    User["User / External Client"]:::external
+
+    Dashboard["Dashboard (UI)<br/>Port 5173"]:::ui
+    MCP["MCP Server<br/>Port 3001"]:::ui
+
+    Core["Core LLM Runtime<br/>Port 3000<br/>(NLP Parsing, Routing, Agent Logic)"]:::core
+
+    ML["ML Engine<br/>Port 8000"]:::core
+    Policy["Policy Engine (Guard)<br/>Unix Socket (IPC) / Loopback"]:::policy
+    Signer["Signer Vault (Safe)<br/>Unix Socket (IPC)"]:::signer
+
+    RPC["Blockchain RPC"]:::blockchain
+
+    User --> Dashboard
+    User --> MCP
+
+    Dashboard --> Core
+    MCP --> Core
+
+    Core <-->|" RAG & Math "| ML
+    Core -->|" Draft Transaction "| Policy
+    Policy -->|" Approved Payload "| Signer
+    Signer --> RPC
+```
+
+*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

@@ -71,7 +71,6 @@ const spawnService = (name, command, args, env, inheritStdio = false, cwd) => {
                 try {
                     const yaml = require('yaml');
                     const configPath = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'config', 'config.yaml');
-                    // Fallback check just in case it hasn't migrated yet
                     const actualConfigPath = fs_1.default.existsSync(configPath) ? configPath : path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'config.yaml');
                     if (fs_1.default.existsSync(actualConfigPath)) {
                         const configStr = fs_1.default.readFileSync(actualConfigPath, 'utf8');
@@ -89,7 +88,12 @@ const spawnService = (name, command, args, env, inheritStdio = false, cwd) => {
                     }
                 }
                 catch (e) { }
-                process.exit(1);
+                console.log('\n[Launcher] Shutting down all services due to emergency shutdown...');
+                children.forEach(c => c.kill());
+                // Give children time to exit cleanly
+                setTimeout(() => {
+                    process.exit(1);
+                }, 1000);
                 return;
             }
             console.log(`[Launcher] Restarting ${name} in 3 seconds... (Attempt ${crashCount}/5)`);
@@ -139,21 +143,69 @@ setTimeout(() => {
     children.push(policy);
     setTimeout(() => {
         // Spawn ML Engine (Python Sidecar)
-        const pythonPath = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'ml-engine', 'venv', 'bin', 'python');
+        // Cross-platform: Windows uses Scripts/, Unix uses bin/
+        const IS_WINDOWS_LAUNCHER = process.platform === 'win32';
+        const pythonBinDir = IS_WINDOWS_LAUNCHER ? 'Scripts' : 'bin';
+        const pythonExe = IS_WINDOWS_LAUNCHER ? 'python.exe' : 'python';
+        const pythonPath = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'ml-engine', 'venv', pythonBinDir, pythonExe);
         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);
         }
         else {
-            console.warn('[Launcher] Warning: Python virtual environment not found. Did you run setup?');
+            console.warn('[Launcher] Warning: Python virtual environment not found. ML Engine features (market analysis etc.) will be unavailable. Run: nyxora setup');
         }
         setTimeout(() => {
             const corePath = path_1.default.join(__dirnameResolved, `packages/core/src/gateway/cli${ext}`);
             const args = process.argv.slice(2);
             const core = spawnService('Core', cmd, [...baseArgs, corePath, ...args], env, true);
             children.push(core);
+            // --- AUTO-TUNNEL (Cloudflare) ---
+            // Respects config: set cloudflare_tunnel: false in ~/.nyxora/config/config.yaml to disable.
+            setTimeout(() => {
+                let cfEnabled = true;
+                try {
+                    const yaml = require('yaml');
+                    const configPath = path_1.default.join(nyxoraDir, 'config', 'config.yaml');
+                    const fallbackPath = path_1.default.join(nyxoraDir, 'config.yaml');
+                    const actualPath = fs_1.default.existsSync(configPath) ? configPath : fallbackPath;
+                    if (fs_1.default.existsSync(actualPath)) {
+                        const cfg = yaml.parse(fs_1.default.readFileSync(actualPath, 'utf8'));
+                        if (cfg?.cloudflare_tunnel === false) {
+                            cfEnabled = false;
+                            console.log('[Launcher] Cloudflare Auto-Tunnel is disabled by config (cloudflare_tunnel: false).');
+                        }
+                    }
+                }
+                catch (e) { }
+                if (cfEnabled) {
+                    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();
+                        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');
+                        }
+                    });
+                }
+            }, 3000);
         }, 1000);
     }, 1000);
 }, 1000);
@@ -173,11 +225,17 @@ const cleanup = () => {
             }
             catch (e) { }
         });
-        try {
-            require('child_process').execSync('pkill -f ts-node');
-            require('child_process').execSync('pkill -f uvicorn');
+        // pkill is Unix-only — skip on Windows
+        if (process.platform !== 'win32') {
+            try {
+                require('child_process').execSync('pkill -f ts-node');
+            }
+            catch (e) { }
+            try {
+                require('child_process').execSync('pkill -f uvicorn');
+            }
+            catch (e) { }
         }
-        catch (e) { }
         process.exit(0);
     }, 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

@@ -8,9 +8,18 @@ class OpenAIAdapter {
     }
     async chat(request) {
         const response = await this.client.chat.completions.create(request);
+        let content = response.choices[0].message.content || '';
+        let reasoning = response.choices[0].message.reasoning_content || null;
+        // Extract <thinking> tags from content if present
+        const thinkingMatch = content.match(/<(think|thought|thinking|reasoning|analysis|reflection)>([\s\S]*?)<\/\1>/i);
+        if (thinkingMatch) {
+            reasoning = (reasoning || '') + thinkingMatch[2].trim();
+            content = content.replace(/<(think|thought|thinking|reasoning|analysis|reflection)>[\s\S]*?<\/\1>\n?/i, '').trim();
+        }
         return {
             message: {
-                content: response.choices[0].message.content,
+                content: content || null,
+                reasoning_content: reasoning || null,
                 tool_calls: response.choices[0].message.tool_calls
             },
             usage: response.usage ? { total_tokens: response.usage.total_tokens } : undefined
@@ -20,6 +29,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 +37,9 @@ class OpenAIAdapter {
                     fullContent += delta.content;
                     onChunk(delta.content);
                 }
+                if (delta?.reasoning_content || delta?.reasoning) {
+                    reasoningContent += (delta.reasoning_content || delta.reasoning);
+                }
                 if (delta?.tool_calls) {
                     for (const tc of delta.tool_calls) {
                         if (!toolCallsMap[tc.index]) {
@@ -44,9 +57,16 @@ class OpenAIAdapter {
                 }
             }
             const toolCalls = Object.values(toolCallsMap);
+            // Post-process to extract <thinking> tags that were streamed as part of content
+            const thinkingMatch = fullContent.match(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>([\s\S]*?)<\/\1>/i);
+            if (thinkingMatch) {
+                reasoningContent = (reasoningContent || '') + thinkingMatch[2].trim();
+                fullContent = fullContent.replace(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>[\s\S]*?<\/\1>\n?/i, '').trim();
+            }
             return {
                 message: {
                     content: fullContent || null,
+                    reasoning_content: reasoningContent || null,
                     tool_calls: toolCalls.length > 0 ? toolCalls : undefined
                 }
             };
@@ -55,6 +75,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 +170,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,
@@ -165,9 +190,17 @@ class AnthropicAdapter {
                 });
             }
         }
+        if (contentStr) {
+            const thinkingMatch = contentStr.match(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>([\s\S]*?)<\/\1>/i);
+            if (thinkingMatch) {
+                reasoningStr = (reasoningStr || '') + thinkingMatch[2].trim();
+                contentStr = contentStr.replace(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>[\s\S]*?<\/\1>\n?/i, '').trim();
+            }
+        }
         return {
             message: {
-                content: contentStr,
+                content: contentStr || null,
+                reasoning_content: reasoningStr || null,
                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined
             },
             usage: response.usage ? { total_tokens: response.usage.input_tokens + response.usage.output_tokens } : undefined
@@ -233,12 +266,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 +285,22 @@ class AnthropicAdapter {
                         last.function.arguments += event.delta.partial_json;
                 }
             }
-            return { message: { content: fullContent || null, tool_calls: toolCalls.length > 0 ? toolCalls : undefined } };
+            if (fullContent) {
+                const thinkingMatch = fullContent.match(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>([\s\S]*?)<\/\1>/i);
+                if (thinkingMatch) {
+                    reasoningContent = (reasoningContent || '') + thinkingMatch[2].trim();
+                    fullContent = fullContent.replace(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>[\s\S]*?<\/\1>\n?/i, '').trim();
+                }
+            }
+            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;
         }
     }
 }
@@ -385,9 +434,18 @@ class GeminiAdapter {
         if (data.usageMetadata && data.usageMetadata.totalTokenCount) {
             totalTokens = data.usageMetadata.totalTokenCount;
         }
+        let reasoningContent = null;
+        if (contentStr) {
+            const thinkingMatch = contentStr.match(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>([\s\S]*?)<\/\1>/i);
+            if (thinkingMatch) {
+                reasoningContent = thinkingMatch[2].trim();
+                contentStr = contentStr.replace(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>[\s\S]*?<\/\1>\n?/i, '').trim();
+            }
+        }
         return {
             message: {
-                content: contentStr,
+                content: contentStr || null,
+                reasoning_content: reasoningContent || null,
                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined
             },
             usage: totalTokens > 0 ? { total_tokens: totalTokens } : undefined
@@ -504,13 +562,26 @@ class GeminiAdapter {
                     }
                 }
             }
+            let reasoningContent = null;
+            if (contentStr) {
+                const thinkingMatch = contentStr.match(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>([\s\S]*?)<\/\1>/i);
+                if (thinkingMatch) {
+                    reasoningContent = thinkingMatch[2].trim();
+                    contentStr = contentStr.replace(/<(think|thought|thinking|reasoning|analysis|reflection|ant-thinking|ant_thinking)[^>]*>[\s\S]*?<\/\1>\n?/i, '').trim();
+                }
+            }
             return {
-                message: { content: contentStr || null, tool_calls: toolCalls.length > 0 ? toolCalls : undefined },
+                message: { content: contentStr || null, reasoning_content: reasoningContent || null, tool_calls: toolCalls.length > 0 ? toolCalls : undefined },
                 usage: totalTokens > 0 ? { total_tokens: totalTokens } : 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;
         }
     }
 }

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

@@ -55,7 +55,7 @@ class NyxDaemon {
                 this.isProcessing = false;
                 return;
             }
-            // Kirim riwayat percakapan ke Python ML Engine untuk diproses oleh LangChain
+            // Send conversation history to Python ML Engine for cognitive modeling
             const res = await fetch('http://127.0.0.1:8000/cognitive/reason', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
@@ -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) {