nyxora 26.7.2 → 26.7.3

package/dist/launcher.js

@@ -26,20 +26,28 @@ const env = {
     ...process.env,
     INTERNAL_AUTH_TOKEN,
     SIGNER_SOCKET_PATH: '/tmp/nyxora-signer.sock',
-    TS_NODE_CACHE: 'false'
+    TS_NODE_CACHE: 'false',
+    PYTHONUNBUFFERED: '1'
 };
-const spawnService = (name, command, args, env, inheritStdio = false) => {
+const spawnService = (name, command, args, env, inheritStdio = false, cwd) => {
     let child;
     let crashCount = 0;
     let crashWindowStart = Date.now();
     let isShuttingDown = false;
     const startProcess = () => {
-        child = (0, child_process_1.spawn)(command, args, { env, stdio: inheritStdio ? 'inherit' : 'pipe' });
+        const spawnOpts = { env, stdio: inheritStdio ? 'inherit' : 'pipe' };
+        if (cwd)
+            spawnOpts.cwd = cwd;
+        child = (0, child_process_1.spawn)(command, args, spawnOpts);
+        child.on('error', (err) => {
+            console.error(`[Launcher] Failed to spawn ${name}:`, err.message);
+            isShuttingDown = true; // Prevent retry loop if spawn fails
+        });
         if (!inheritStdio) {
             child.stdout?.on('data', (data) => process.stdout.write(`[${name}] ${data}`));
             child.stderr?.on('data', (data) => {
                 const msg = data.toString();
-                if (msg.toLowerCase().includes('warn')) {
+                if (msg.toLowerCase().includes('warn') || msg.toLowerCase().includes('info')) {
                     process.stderr.write(`[${name}] ${msg}`);
                 }
                 else {
@@ -98,6 +106,14 @@ const spawnService = (name, command, args, env, inheritStdio = false) => {
                 }
                 catch (e) { }
             }
+        },
+        forceKill: () => {
+            if (child && !child.killed && child.pid) {
+                try {
+                    process.kill(child.pid, 'SIGKILL');
+                }
+                catch (e) { }
+            }
         }
     };
 };
@@ -122,10 +138,23 @@ setTimeout(() => {
     const policy = spawnService('Policy', cmd, [...baseArgs, policyPath], env);
     children.push(policy);
     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);
+        // 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');
+            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?');
+        }
+        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);
+        }, 1000);
     }, 1000);
 }, 1000);
 // Ensure all child processes are killed when launcher exits
@@ -138,8 +167,15 @@ const cleanup = () => {
     children.forEach(c => c.kill());
     // Give them a moment to cleanup
     setTimeout(() => {
+        children.forEach(c => {
+            try {
+                c.forceKill();
+            }
+            catch (e) { }
+        });
         try {
             require('child_process').execSync('pkill -f ts-node');
+            require('child_process').execSync('pkill -f uvicorn');
         }
         catch (e) { }
         process.exit(0);

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/cronManager.js

@@ -44,7 +44,7 @@ const crypto_1 = require("crypto");
 const picocolors_1 = __importDefault(require("picocolors"));
 class CronManager {
     jobs = new Map();
-    addJob(expression, prompt) {
+    addJob(expression, prompt, sessionId) {
         const id = (0, crypto_1.randomUUID)();
         // Validate expression
         try {
@@ -59,7 +59,7 @@ class CronManager {
                 // Dynamically import processUserInput to avoid circular dependencies
                 const { processUserInput } = await Promise.resolve().then(() => __importStar(require('./reasoning')));
                 // Execute the prompt as a background system task
-                const response = await processUserInput(prompt, 'system', undefined, `cron-${id}`);
+                const response = await processUserInput(prompt, 'system', undefined, sessionId || `cron-${id}`);
                 // Push notification to Telegram if configured
                 const config = (0, parser_1.loadConfig)();
                 if (config.integrations?.telegram?.enabled && config.integrations?.telegram?.authorized_chat_id) {

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

@@ -16,6 +16,50 @@ 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 (e) {
+            // Fallback to non-streaming if streaming fails
+            const chatRes = await this.chat(request);
+            if (chatRes.message.content) {
+                onChunk(chatRes.message.content);
+            }
+            return chatRes;
+        }
+    }
 }
 exports.OpenAIAdapter = OpenAIAdapter;
 class AnthropicAdapter {
@@ -129,6 +173,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 +390,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,97 @@
+"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 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 30 seconds (faster persona availability for new sessions)
+        this.initialTimeout = setTimeout(() => {
+            this.runAudit();
+        }, 30 * 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;
+            }
+            // Kirim riwayat percakapan ke Python ML Engine untuk diproses oleh LangChain
+            const res = await fetch('http://localhost:8000/cognitive/reason', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ messages: conversationOnly })
+            });
+            if (!res.ok) {
+                throw new Error(`Python ML Engine returned ${res.status}: ${await res.text()}`);
+            }
+            const traits = await res.json();
+            try {
+                if (traits && typeof traits === 'object' && !Array.isArray(traits)) {
+                    const categories = ['language', 'tone', 'trading_style', 'behavior'];
+                    for (const cat of categories) {
+                        const value = traits[cat];
+                        if (value && typeof value === 'string' && value.trim()) {
+                            // Category-based upsert: confidence accumulates correctly per category
+                            episodic_1.episodicDB.upsertPersonaByCategory(cat, value.trim(), 0.5, 'nyx_daemon');
+                            console.log(picocolors_1.default.magenta(`[Nyx] Updated persona [${cat}]: ${value.trim()}`));
+                        }
+                    }
+                }
+                else {
+                    console.log(picocolors_1.default.magenta('[Nyx] No strong traits found in this audit cycle.'));
+                }
+            }
+            catch (e) {
+                console.error(picocolors_1.default.red('[Nyx] Failed to process traits from Python'), traits);
+            }
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`[Nyx] Analysis failed: ${e.message}`));
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+}
+exports.NyxDaemon = NyxDaemon;
+exports.nyxDaemon = new NyxDaemon();