nyxora 26.7.2-alpha.1 → 26.7.2-alpha.4

package/CHANGELOG.md

@@ -3,7 +3,27 @@
 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/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [26.7.2-alpha.4]
+### Features & Platform Integrations
+- **Telegram Native Streaming (Bot API 9.3+)**: Radically overhauled the Telegram bot integration to completely bypass the standard 1-second `editMessageText` API rate limit. The engine now natively implements the modern `sendMessageDraft` method, streaming ephemeral hardware-accelerated "Typing..." animations directly to the Telegram client at 100ms intervals. This fully resolves UI stuttering and achieves ultra-smooth, real-time typewriter effects matching premium web interfaces.
+
+### Bug Fixes & Stability
+- **Telegram Polling Timeout Silence**: Mitigated an issue where sudden network disconnects or API timeouts (`ETIMEDOUT`) would cause the `@grammyjs/runner` to spam the console with massive stack traces. The system now seamlessly intercepts these failures via a custom API config transformer, suppresses the default runner logs, and gracefully emits a clean, single-line reconnection warning.
+
+## [26.7.2-alpha.3]
+### Hotfixes
+- **Daemon Crash & Missing Dependency**: Resolved a critical crash preventing `nyxora start` from booting the daemon by properly injecting the missing `discord.js` dependency into the core package requirements.
+- **MCP Server TypeScript Rigidity**: Fixed a severe TypeScript compilation failure on the MCP Server caused by an un-asserted `type: "text"` field within the JSON-RPC return shape, ensuring `alpha.3` builds securely and passes strict compilation checks before deployment.
+
+## [26.7.2-alpha.2]
+- **Core Stability & Graceful Shutdown**: Engineered a robust `Graceful Shutdown` hook in the Gateway API (`server.ts`) to actively track floating Web3 transaction promises. Nyxora now intelligently waits up to 10 seconds for on-chain transactions to finalize before shutting down, completely eradicating dangling transactions and fund loss during SIGINT/SIGTERM.
+- **SQLite Transaction Persistence**: Overhauled `transactionManager.ts` to migrate away from volatile RAM Maps and JSON files (`.nyxora_withdrawals.json`). All pending transactions and L2 withdrawals are now persistently written to `memory.db` via `logger.ts`, guaranteeing 100% state recovery and ACID compliance across sudden power losses or daemon reboots.
+- **Atomic File Operations**: Fortified configuration write operations (`config.yaml` and Google Credentials) in `parser.ts` using OS-level atomic renames (`fs.renameSync`). This mechanically eliminates the possibility of 0-byte file corruption during sudden server crashes.
+- **Unified Message Bus (Multi-Platform Integration)**: Radically expanded Nyxora's gateway architecture beyond Telegram and the Web Dashboard. Successfully engineered and deployed a unified multi-platform message bus:
+  - **Discord Integration**: Engineered `discordAdapter.ts` using `discord.js` to allow Nyxora to natively join Discord servers, intercept mentions, and stream Markdown-rich responses via WebSockets in real-time.
+  - **Multi-Identity Tracking**: Overhauled the core `logger.ts` memory architecture to persistently track user dialects across multiple platforms by dynamically segmenting SQLite session IDs (`discord_<id>`, `telegram_<id>`).
+- **Light Theme Login Readability**: Resolved a severe contrast issue on the Dashboard Login screen. In Light Mode, the dark text was practically invisible against the hardcoded dark card. Appended strict `body.light-theme` overrides in `Login.css` to seamlessly transition the card into a readable "glass" background without polluting or breaking the existing Dark Mode aesthetics.
+- **Background Daemon Identity Integration**: Officially formalized the naming convention of the Dialectic User Modeling background process to **Nyx Daemon**. Realigned all core TypeScript files (`nyxDaemon.ts`), internal system logging prefixes, and public documentation to reflect this unified system identity, ensuring a seamless aesthetic and conceptual integration with the broader Nyxora ecosystem.
 
 ## [26.7.2-alpha.1]
 ### Security & Architecture

package/README.md

@@ -13,7 +13,7 @@
 
 Nyxora is a **secure, non-custodial runtime infrastructure for autonomous onchain agents** built with a robust Monorepo architecture (Node.js & React). Designed for autonomous workflows with a premium Utility-Centric dark-themed UI and strict client-side key isolation. 
 
-**Nyxora now natively supports the Model Context Protocol (MCP)**. You can transform your external AI agents (like Claude Desktop and Cursor) into secure Web3 actors that execute swaps and fetch balances using Nyxora's secure signer vault. [View the MCP Integration Guide](https://nyxoraai.github.io/Nyxora/guide/mcp-integration)
+**Nyxora now natively supports the Model Context Protocol (MCP)**. You can transform your external AI agents (like Claude Desktop and Cursor) into secure Web3 actors that execute swaps and fetch balances using Nyxora's secure signer vault. [View the MCP Integration Guide](https://nyxoraai.github.io/Nyxora/mcp/)
 
 It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human-in-the-Loop** execution model, ensuring that Remote AIs (LLMs) never have unilateral access to your funds.
 
@@ -67,7 +67,7 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 ## 🔥 Key Features
 
 ### 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/security/smart-contract)
+*   **🛡️ 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)
 *   **3-Tier IPC Architecture**: Nyxora is split into isolated processes: **Core** (LLM Runtime), **Policy Engine** (Guardrails on port 3001), and **Signer Vault** (Isolated Key Manager on Unix Sockets).
 *   **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.
@@ -100,7 +100,7 @@ It operates under a **Zero-Trust, Defense-in-Depth Cryptographically Bound Human
 ### 🧠 The Masterpiece Memory Architecture
 *   **4-Layer Air-Gapped Vault**: Nyxora features a god-tier memory system that completely isolates conversational habits from the OS Keyring. The AI can dynamically learn your behaviors without ever having physical read-paths to your private keys.
 *   **Hard-Coded Anti-Injection Shield**: We enforce a Zero-Trust memory paradigm. Before any user habit is saved to the local SQLite database, it must pass a strict RegExp-based validation layer that autonomously annihilates Private Keys, BIP-39 Seed Phrases, and Prompt Injection attempts.
-*   **Dialectic User Modeling (Honcho Daemon)**: Nyxora continuously runs an asynchronous background daemon that quietly audits your conversational history. It extracts your behavioral traits, trading style, and risk tolerance, saving them securely to `episodic.db` and injecting them dynamically into the AI's reasoning engine.
+*   **Dialectic User Modeling (Nyx Daemon)**: Nyxora continuously runs an asynchronous background daemon that quietly audits your conversational history. It extracts your behavioral traits, trading style, and risk tolerance, saving them securely to `episodic.db` and injecting them dynamically into the AI's reasoning engine.
 *   **Smart Suggestion Engine**: Nyxora actively queries its Layer-2 Episodic Database to seamlessly autocomplete your repetitive Web3 routines. If you always swap on Arbitrum using USDC, the AI will proactively suggest it, slashing human-in-the-loop latency by up to 90%.
 
 ### AI & UI Customization
@@ -138,7 +138,7 @@ Within the AI Brain, the Web3 codebase is strictly divided to prevent the LLM fr
 
 ## 🛡️ Advanced Security & Threat Model
 
-To dive deeper into the technical details of our Zero-Knowledge security architecture, please visit the [Nyxora Security](https://nyxoraai.github.io/Nyxora/).
+To dive deeper into the technical details of our Zero-Knowledge security architecture, please visit the [Nyxora Security](https://nyxoraai.github.io/Nyxora/architecture).
 
 ---
 

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

@@ -8,7 +8,8 @@ const parser_1 = require("../config/parser");
 // to fetch the Merkle Proof and call proveWithdrawalTransaction on L1.
 // For the scope of this architecture prototype, we simulate the Challenge Period
 // watcher by using a time-delay, representing the exact asynchronous behavior.
-const CHALLENGE_PERIOD_MS = 2 * 60 * 1000; // Simulating a 2-minute challenge period for testnet demo
+// Actual 7-day challenge period for OP Stack and Arbitrum withdrawals
+const CHALLENGE_PERIOD_MS = 7 * 24 * 60 * 60 * 1000;
 function startBridgeWatcher() {
     console.log('[Bridge Watcher] Started background daemon for asynchronous L2 withdrawals');
     setInterval(async () => {
@@ -30,5 +31,5 @@ function startBridgeWatcher() {
                 }
             }
         }
-    }, 30000); // Check every 30 seconds
+    }, 12 * 60 * 60 * 1000); // Check every 12 hours
 }

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

@@ -16,6 +16,46 @@ class OpenAIAdapter {
             usage: response.usage ? { total_tokens: response.usage.total_tokens } : undefined
         };
     }
+    async stream(request, onChunk) {
+        try {
+            const streamRes = await this.client.chat.completions.create({ ...request, stream: true });
+            let fullContent = '';
+            const toolCallsMap = {};
+            for await (const chunk of streamRes) {
+                const delta = chunk.choices[0]?.delta;
+                if (delta?.content) {
+                    fullContent += delta.content;
+                    onChunk(delta.content);
+                }
+                if (delta?.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        if (!toolCallsMap[tc.index]) {
+                            toolCallsMap[tc.index] = { id: tc.id || '', type: 'function', function: { name: tc.function?.name || '', arguments: tc.function?.arguments || '' } };
+                        }
+                        else {
+                            if (tc.id)
+                                toolCallsMap[tc.index].id = tc.id;
+                            if (tc.function?.name)
+                                toolCallsMap[tc.index].function.name += tc.function.name;
+                            if (tc.function?.arguments)
+                                toolCallsMap[tc.index].function.arguments += tc.function.arguments;
+                        }
+                    }
+                }
+            }
+            const toolCalls = Object.values(toolCallsMap);
+            return {
+                message: {
+                    content: fullContent || null,
+                    tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+                }
+            };
+        }
+        catch {
+            // Fallback to non-streaming if streaming fails
+            return this.chat(request);
+        }
+    }
 }
 exports.OpenAIAdapter = OpenAIAdapter;
 class AnthropicAdapter {
@@ -129,6 +169,84 @@ class AnthropicAdapter {
             usage: response.usage ? { total_tokens: response.usage.input_tokens + response.usage.output_tokens } : undefined
         };
     }
+    async stream(request, onChunk) {
+        try {
+            // Build the same message format as chat()
+            let systemPrompt = '';
+            const anthropicMessages = [];
+            for (const m of request.messages) {
+                if (m.role === 'system') {
+                    systemPrompt = m.content;
+                    continue;
+                }
+                if (m.role === 'user') {
+                    anthropicMessages.push({ role: 'user', content: m.content });
+                }
+                else if (m.role === 'assistant') {
+                    const blocks = [];
+                    if (m.content)
+                        blocks.push({ type: 'text', text: m.content });
+                    if (m.tool_calls)
+                        m.tool_calls.forEach((tc) => {
+                            try {
+                                blocks.push({ type: 'tool_use', id: tc.id, name: tc.function.name, input: JSON.parse(tc.function.arguments) });
+                            }
+                            catch { }
+                        });
+                    anthropicMessages.push({ role: 'assistant', content: blocks.length > 0 ? blocks : m.content });
+                }
+                else if (m.role === 'tool') {
+                    anthropicMessages.push({ role: 'user', content: [{ type: 'tool_result', tool_use_id: m.tool_call_id, content: m.content }] });
+                }
+            }
+            const mergedAnthropic = [];
+            for (const m of anthropicMessages) {
+                const last = mergedAnthropic[mergedAnthropic.length - 1];
+                if (last && last.role === m.role) {
+                    if (Array.isArray(last.content) && Array.isArray(m.content))
+                        last.content.push(...m.content);
+                    else if (typeof last.content === 'string' && typeof m.content === 'string')
+                        last.content += '\n\n' + m.content;
+                    else if (Array.isArray(last.content) && typeof m.content === 'string')
+                        last.content.push({ type: 'text', text: m.content });
+                    else
+                        last.content = [{ type: 'text', text: typeof last.content === 'string' ? last.content : '' }, ...m.content];
+                }
+                else {
+                    mergedAnthropic.push(m);
+                }
+            }
+            const anthropicTools = request.tools?.map(t => ({ name: t.function.name, description: t.function.description, input_schema: t.function.parameters }));
+            const stream = this.client.messages.stream({
+                model: request.model,
+                system: systemPrompt,
+                messages: mergedAnthropic,
+                tools: anthropicTools,
+                temperature: request.temperature,
+                max_tokens: request.max_tokens || 4096
+            });
+            let fullContent = '';
+            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_start' && event.content_block.type === 'tool_use') {
+                    toolCalls.push({ id: event.content_block.id, type: 'function', function: { name: event.content_block.name, arguments: '' } });
+                }
+                if (event.type === 'content_block_delta' && event.delta.type === 'input_json_delta') {
+                    const last = toolCalls[toolCalls.length - 1];
+                    if (last)
+                        last.function.arguments += event.delta.partial_json;
+                }
+            }
+            return { message: { content: fullContent || null, tool_calls: toolCalls.length > 0 ? toolCalls : undefined } };
+        }
+        catch {
+            return this.chat(request);
+        }
+    }
 }
 exports.AnthropicAdapter = AnthropicAdapter;
 class GeminiAdapter {
@@ -268,5 +386,125 @@ class GeminiAdapter {
             usage: totalTokens > 0 ? { total_tokens: totalTokens } : undefined
         };
     }
+    async stream(request, onChunk) {
+        let systemInstruction = '';
+        const contents = [];
+        for (const m of request.messages) {
+            if (m.role === 'system') {
+                systemInstruction = m.content;
+                continue;
+            }
+            if (m.role === 'user') {
+                contents.push({ role: 'user', parts: [{ text: m.content }] });
+            }
+            else if (m.role === 'assistant') {
+                const parts = [];
+                if (m.content)
+                    parts.push({ text: m.content });
+                if (m.tool_calls) {
+                    m.tool_calls.forEach((tc) => {
+                        try {
+                            parts.push({ functionCall: { name: tc.function.name, args: JSON.parse(tc.function.arguments) } });
+                        }
+                        catch { }
+                    });
+                }
+                if (parts.length > 0)
+                    contents.push({ role: 'model', parts });
+            }
+            else if (m.role === 'tool') {
+                contents.push({ role: 'user', parts: [{ functionResponse: { name: m.name || 'unknown_tool', response: { result: m.content } } }] });
+            }
+        }
+        const mergedContents = [];
+        for (const m of contents) {
+            const last = mergedContents[mergedContents.length - 1];
+            if (last && last.role === m.role)
+                last.parts.push(...m.parts);
+            else
+                mergedContents.push(m);
+        }
+        let tools = undefined;
+        if (request.tools && request.tools.length > 0) {
+            tools = [{ functionDeclarations: request.tools.map(t => ({ name: t.function.name, description: t.function.description, parameters: t.function.parameters })) }];
+        }
+        const payload = {
+            contents: mergedContents,
+            generationConfig: { temperature: request.temperature || 0.7 },
+            safetySettings: [
+                { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_NONE' },
+                { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_NONE' },
+                { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' },
+                { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_NONE' }
+            ]
+        };
+        if (systemInstruction)
+            payload.systemInstruction = { parts: [{ text: systemInstruction }] };
+        if (tools)
+            payload.tools = tools;
+        try {
+            const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${request.model}:streamGenerateContent?alt=sse&key=${this.apiKey}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            if (!response.ok)
+                return this.chat(request);
+            let contentStr = '';
+            const toolCalls = [];
+            let totalTokens = 0;
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+            if (reader) {
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const raw = line.slice(6).trim();
+                        if (!raw || raw === '[DONE]')
+                            continue;
+                        try {
+                            const data = JSON.parse(raw);
+                            if (data.candidates && data.candidates.length > 0) {
+                                const candidate = data.candidates[0];
+                                if (candidate.content && candidate.content.parts) {
+                                    for (const part of candidate.content.parts) {
+                                        if (part.text) {
+                                            contentStr += part.text;
+                                            onChunk(part.text);
+                                        }
+                                        else if (part.functionCall) {
+                                            toolCalls.push({
+                                                id: `call_${Math.random().toString(36).substring(7)}`,
+                                                type: 'function',
+                                                function: { name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args || {}) }
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            if (data.usageMetadata?.totalTokenCount)
+                                totalTokens = data.usageMetadata.totalTokenCount;
+                        }
+                        catch { }
+                    }
+                }
+            }
+            return {
+                message: { content: contentStr || null, tool_calls: toolCalls.length > 0 ? toolCalls : undefined },
+                usage: totalTokens > 0 ? { total_tokens: totalTokens } : undefined
+            };
+        }
+        catch {
+            return this.chat(request);
+        }
+    }
 }
 exports.GeminiAdapter = GeminiAdapter;

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

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nyxDaemon = exports.NyxDaemon = void 0;
+const parser_1 = require("../config/parser");
+const llmUtils_1 = require("../utils/llmUtils");
+const episodic_1 = require("../memory/episodic");
+const reasoning_1 = require("./reasoning");
+const picocolors_1 = __importDefault(require("picocolors"));
+class NyxDaemon {
+    isProcessing = false;
+    interval = null;
+    initialTimeout = null;
+    start() {
+        if (this.interval)
+            return;
+        // Initial run after 5 minutes
+        this.initialTimeout = setTimeout(() => {
+            this.runAudit();
+        }, 5 * 60 * 1000);
+        // Audit memory every 30 minutes
+        this.interval = setInterval(() => {
+            this.runAudit();
+        }, 30 * 60 * 1000);
+        console.log(picocolors_1.default.magenta('[Nyx] Dialectic User Modeling daemon started.'));
+    }
+    stop() {
+        if (this.initialTimeout) {
+            clearTimeout(this.initialTimeout);
+            this.initialTimeout = null;
+        }
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+            console.log(picocolors_1.default.magenta('[Nyx] Daemon stopped.'));
+        }
+    }
+    async runAudit() {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        try {
+            console.log(picocolors_1.default.magenta('[Nyx] Running dialectic user modeling...'));
+            // Fix A: Use getRecentMessagesAllSessions so Telegram/Discord history is included.
+            // Previously getHistory(undefined) only read session_id IS NULL — Telegram sessions have a session_id.
+            const history = reasoning_1.logger.getRecentMessagesAllSessions(30);
+            // Fix B: Filter noise — only send plain user & assistant text messages to the LLM.
+            // Skip tool messages, system messages, and assistant entries that only contain tool_calls.
+            const conversationOnly = history.filter(m => (m.role === 'user' || m.role === 'assistant') &&
+                m.content &&
+                m.content.trim().length > 0 &&
+                !m.tool_calls);
+            if (conversationOnly.length < 5) {
+                console.log(picocolors_1.default.magenta('[Nyx] Not enough conversation messages to analyze, skipping.'));
+                this.isProcessing = false;
+                return;
+            }
+            const config = (0, parser_1.loadConfig)();
+            const prompt = `You are Nyx, Nyxora's background Persona Auditor.
+Analyze the following recent conversation between the USER and Nyxora.
+Identify any persistent user traits, behavioral preferences, trading styles, AND language preferences.
+Output your findings AS A STRICT JSON ARRAY of strings. If no strong traits are found, output an empty array [].
+Examples of valid traits:
+- Behavior: "Prefers concise answers", "Aggressive trader", "Risk-averse", "Polite", "Often trades on Arbitrum"
+- Language: "Primarily speaks Indonesian", "Uses English for technical terms", "Communicates in casual/informal tone", "Mixes Indonesian and English (code-switching)"
+IMPORTANT: Always include a language preference trait if the user's language or communication style is identifiable.
+DO NOT output markdown, just the JSON array.`;
+            const messages = conversationOnly
+                .map((m) => `${m.role === 'user' ? 'USER' : 'NYXORA'}: ${m.content}`)
+                .join('\n');
+            const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
+                return await client.chat({
+                    model: config.llm.model,
+                    messages: [
+                        { role: 'system', content: prompt },
+                        { role: 'user', content: messages }
+                    ],
+                    temperature: 0.2
+                });
+            });
+            let content = response.message.content || '[]';
+            // Clean markdown if any
+            content = content.replace(/\`\`\`json/g, '').replace(/\`\`\`/g, '').trim();
+            try {
+                const traits = JSON.parse(content);
+                if (Array.isArray(traits) && traits.length > 0) {
+                    for (const trait of traits) {
+                        // Fix C: Start confidence at 0.4 (not 0.8) so traits build up gradually across audits.
+                        // updatePersonaTrait has upsert logic: repeated traits gain +0.4 * 0.2 per audit cycle.
+                        episodic_1.episodicDB.updatePersonaTrait(trait, 0.4, 'nyx_daemon');
+                        console.log(picocolors_1.default.magenta(`[Nyx] Discovered new trait: ${trait}`));
+                    }
+                }
+            }
+            catch (e) {
+                console.error(picocolors_1.default.red('[Nyx] Failed to parse JSON traits'), content);
+            }
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`[Nyx] Analysis failed: ${e.message}`));
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+}
+exports.NyxDaemon = NyxDaemon;
+exports.nyxDaemon = new NyxDaemon();

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 exports.processOsIntent = processOsIntent;
+exports.processOsIntentStream = processOsIntentStream;
 const parser_1 = require("../config/parser");
 const logger_1 = require("../memory/logger");
 const tracker_1 = require("../gateway/tracker");
@@ -229,3 +230,118 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
         return errorMsg;
     }
 }
+async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
+    const config = (0, parser_1.loadConfig)();
+    exports.logger.addEntry({ role: 'user', content: input }, sessionId);
+    const pluginTools = registry_1.pluginManager.getAllToolDefinitions();
+    let activeTools = [...pluginTools].filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
+    const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
+    try {
+        let turnCount = 0;
+        const MAX_TURNS = 10;
+        let fullResponse = '';
+        while (turnCount < MAX_TURNS) {
+            turnCount++;
+            const currentHistory = exports.logger.getHistory(sessionId);
+            const sanitizedHistory = sanitizeHistoryForLLM(currentHistory, activeTools, config.llm.provider);
+            const messages = [
+                { role: 'system', content: getSystemPrompt('os', input) },
+                ...sanitizedHistory
+            ];
+            let streamedContent = '';
+            const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
+                return await client.stream({ model: config.llm.model, temperature: config.llm.temperature, messages, tools: activeTools }, (chunk) => {
+                    streamedContent += chunk;
+                    onChunk(chunk);
+                });
+            });
+            const responseMessage = response.message;
+            if (turnCount === 1)
+                tracker_1.Tracker.addMessage();
+            if (response.usage?.total_tokens)
+                tracker_1.Tracker.addTokens(response.usage.total_tokens, config.llm.provider);
+            tracker_1.Tracker.addEvent('llm.response', { provider: config.llm.provider, tool_calls: responseMessage.tool_calls?.length || 0 });
+            exports.logger.addEntry({
+                role: 'assistant',
+                content: responseMessage.content || '',
+                tool_calls: responseMessage.tool_calls,
+            }, sessionId);
+            if (!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) {
+                let finalContent = responseMessage.content || 'No response generated.';
+                finalContent = finalContent.replace(/<(think|thought|thinking|reasoning|analysis|reflection)[\s\S]*?<\/\1>\n?/gi, '').trim();
+                fullResponse = finalContent;
+                break;
+            }
+            // Tool calls detected — pause stream visually and execute tools
+            const fastReturnTools = ['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3'];
+            let canFastReturnAll = true;
+            const accumulatedResults = [];
+            for (const _toolCall of responseMessage.tool_calls) {
+                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}..._`);
+                try {
+                    let argStr = toolCall.function.arguments;
+                    if (argStr && !argStr.trim().endsWith('}'))
+                        argStr += '}';
+                    args = JSON.parse(argStr);
+                }
+                catch (parseError) {
+                    result = `[System Error] Arguments for ${toolName} must be valid JSON. Error: ${parseError.message}`;
+                    exports.logger.addEntry({ role: 'tool', tool_call_id: toolCall.id, content: result }, sessionId);
+                    continue;
+                }
+                if (!(0, skillManager_1.isSkillActive)(toolName)) {
+                    result = `[System Error] Access denied: Skill '${toolName}' is currently disabled.`;
+                    exports.logger.addEntry({ role: 'tool', tool_call_id: toolCall.id, content: result }, sessionId);
+                    continue;
+                }
+                try {
+                    const pluginResult = await registry_1.pluginManager.executeTool(toolName, args, { sessionId });
+                    result = pluginResult !== null ? pluginResult : `Error: Tool ${toolName} is not implemented.`;
+                    if (result.includes('[Security Blocked]') || result.startsWith('Error:')) {
+                        console.log(picocolors_1.default.red(`[❌ Failed] Tool ${toolName} returned an error or was blocked.`));
+                    }
+                    else {
+                        console.log(picocolors_1.default.green(`[✅ Success] Tool ${toolName} executed successfully.`));
+                    }
+                }
+                catch (toolError) {
+                    result = `Error executing ${toolName}: ${toolError.message}`;
+                    console.error(picocolors_1.default.red(`[❌ Error Crash] Execution of ${toolName} failed: ${toolError.message}`));
+                }
+                exports.logger.addEntry({ role: 'tool', tool_call_id: toolCall.id, name: toolName, content: result }, sessionId);
+                accumulatedResults.push(result);
+                if (!fastReturnTools.includes(toolName))
+                    canFastReturnAll = false;
+            }
+            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;
+                break;
+            }
+        }
+        if (!fullResponse) {
+            const maxTurnMsg = '⚠️ Reached maximum interaction limit (10 turns). Please be more specific.';
+            exports.logger.addEntry({ role: 'assistant', content: maxTurnMsg }, sessionId);
+            fullResponse = maxTurnMsg;
+        }
+        return fullResponse;
+    }
+    catch (error) {
+        console.error('LLM Stream Error:', error);
+        const status = error?.status || error?.response?.status;
+        let errorMsg = '⚠️ All models are temporarily rate-limited. Please try again in a few minutes.';
+        if (status === 400 || (error.message && error.message.toLowerCase().includes('invalid'))) {
+            errorMsg = '⚠️ Failed to parse instruction. Please describe your command more specifically.';
+        }
+        exports.logger.addEntry({ role: 'assistant', content: errorMsg }, sessionId);
+        return errorMsg;
+    }
+}