nyxora 26.7.2 → 26.7.3

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

@@ -5,12 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
 exports.processOsIntent = processOsIntent;
+exports.processOsIntentStream = processOsIntentStream;
+const fs_1 = __importDefault(require("fs"));
 const parser_1 = require("../config/parser");
 const logger_1 = require("../memory/logger");
 const tracker_1 = require("../gateway/tracker");
 const episodic_1 = require("../memory/episodic");
 const skillManager_1 = require("../utils/skillManager");
 const cognitiveManager_1 = require("../cognitive/cognitiveManager");
+const reasoningScratchpad_1 = require("./reasoningScratchpad");
+const contextSummarizer_1 = require("../utils/contextSummarizer");
 const EXECUTION_DISCIPLINE = `
 <tool_persistence>
 Use tools whenever they can increase the accuracy, completeness, or factual correctness of your response.
@@ -36,10 +40,11 @@ NEVER fabricate, hallucinate, or forge tool outputs.
 </task_completion>
 `;
 const registry_1 = require("../plugin/registry");
+const paths_1 = require("../config/paths");
 const picocolors_1 = __importDefault(require("picocolors"));
 exports.logger = new logger_1.Logger();
 const llmUtils_1 = require("../utils/llmUtils");
-function getSystemPrompt(context = 'os', userInput = '') {
+async function getSystemPrompt(context = 'os', userInput = '') {
     const config = (0, parser_1.loadConfig)();
     const currentDateTime = new Date().toLocaleString('en-US');
     let basePrompt = `You are Nyxora's OS Agent (System & Automation Specialist).
@@ -49,7 +54,7 @@ Reason internally. Never reveal private reasoning. Provide only concise conclusi
 
 [OS EXECUTION WORKFLOW]
 CRITICAL RULE 1: NEVER expose internal JSON tool calls. Explain the outcome naturally.
-CRITICAL RULE 2: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt.
+CRITICAL RULE 2: STRICT LANGUAGE MATCHING. Reply in the exact same language as the user's LATEST prompt, UNLESS the Episodic Memories or Cognitive Skills specify a strict language preference.
 CRITICAL RULE 3: FILE SYSTEM SAFETY. You are STRICTLY FORBIDDEN from modifying config.yaml, rpc_key.yaml, or policy.yaml using terminal commands like sed or echo.
 CRITICAL RULE 4: CRON JOBS VS LIMIT ORDERS. Do NOT use schedule_task for price-based trading triggers. Use schedule_task for time-based recurring tasks.
 CRITICAL RULE 5: TOOL CONFIDENCE. NEVER fabricate file contents or command outputs.
@@ -61,46 +66,83 @@ ${EXECUTION_DISCIPLINE}
     if (activeSOP) {
         basePrompt += `\n\n[ACTIVE COGNITIVE SKILLS]\n${activeSOP}\n`;
     }
-    // Inject Episodic Memories
+    // Inject Episodic Memories via Python RAG
     try {
-        const recentMemories = episodic_1.episodicDB.getMemories().slice(0, 10);
-        if (recentMemories.length > 0) {
-            basePrompt += `
-
---- EPISODIC MEMORIES (SMART SUGGESTIONS) ---
-`;
-            recentMemories.forEach(mem => {
-                basePrompt += `- [${mem.category.toUpperCase()}] ${mem.fact} (Confidence: ${(mem.confidence * 100).toFixed(0)}%)
-`;
+        const ragRes = await fetch('http://localhost:8000/memory/rag', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query: userInput, top_k: 5 })
+        });
+        if (ragRes.ok) {
+            const ragData = await ragRes.json();
+            if (ragData.memories && ragData.memories.length > 0) {
+                basePrompt += `\n\n--- EPISODIC MEMORIES (SMART SUGGESTIONS) ---\n`;
+                ragData.memories.forEach((mem) => {
+                    basePrompt += `- ${mem}\n`;
+                });
+            }
+        }
+    }
+    catch (e) {
+        // Fallback or ignore if Python ML engine is down
+    }
+    // Inject User Information & Personas from user.md
+    try {
+        const userMdPath = (0, paths_1.getPath)('user.md');
+        if (fs_1.default.existsSync(userMdPath)) {
+            const userInstructions = fs_1.default.readFileSync(userMdPath, 'utf8');
+            basePrompt += `\n\n--- USER INFORMATION & PREFERENCES ---\n${userInstructions}\n`;
+        }
+    }
+    catch (e) {
+        // Ignore error
+    }
+    // HIGHEST PRIORITY: Inject observed user communication style (NyxDaemon)
+    try {
+        const strongPersonas = episodic_1.episodicDB.getStrongPersonas(0.5);
+        if (strongPersonas.length > 0) {
+            basePrompt += `\n\n--- ⚡ OVERRIDE: USER COMMUNICATION STYLE (HIGHEST PRIORITY — OVERRIDES ALL RULES ABOVE) ---\n`;
+            basePrompt += `CRITICAL: These are CONFIRMED user preferences observed across multiple conversations. You MUST apply them IMMEDIATELY and CONSISTENTLY, overriding any default tone or style instructions above.\n\n`;
+            strongPersonas.forEach(p => {
+                const label = p.category ? `[${p.category.toUpperCase()}]` : '[PREFERENCE]';
+                basePrompt += `${label} ${p.trait}\n`;
             });
         }
     }
-    catch { }
+    catch (e) {
+        // Ignore
+    }
     return basePrompt;
 }
 async function processOsIntent(input, role = 'user', onProgress, sessionId) {
     const config = (0, parser_1.loadConfig)();
     // Add input to memory
     exports.logger.addEntry({ role, content: input }, sessionId);
-    const history = exports.logger.getHistory(sessionId);
-    // Format messages for OpenAI
     let activeTools = [...registry_1.pluginManager.getAllToolDefinitions()];
     activeTools = activeTools.filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
+    // P1: Init reasoning scratchpad for this request
+    const scratchpad = new reasoningScratchpad_1.ReasoningScratchpad();
+    // P3: Build system prompt ONCE per request — not per turn
+    const cachedSystemPrompt = await getSystemPrompt('os', input);
     const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
-    const sanitizedHistory = sanitizeHistoryForLLM(history, activeTools, config.llm.provider);
-    let messages = [
-        { role: 'system', content: getSystemPrompt('os', input) },
-        ...sanitizedHistory
-    ];
     try {
         let turnCount = 0;
         const MAX_TURNS = 10;
+        let consecutiveToolErrors = 0;
         while (turnCount < MAX_TURNS) {
             turnCount++;
             const currentHistory = exports.logger.getHistory(sessionId);
-            const sanitizedHistory = sanitizeHistoryForLLM(currentHistory, activeTools, config.llm.provider);
+            // P6: Compress history if conversation is too long
+            const historyToUse = (0, contextSummarizer_1.needsCompression)(currentHistory)
+                ? await (0, contextSummarizer_1.compressHistory)(currentHistory)
+                : currentHistory;
+            const sanitizedHistory = sanitizeHistoryForLLM(historyToUse, activeTools, config.llm.provider);
+            // P1: Inject scratchpad into system prompt for turns > 1
+            const sysPrompt = turnCount === 1
+                ? cachedSystemPrompt
+                : cachedSystemPrompt + scratchpad.getInjection();
             const messages = [
-                { role: 'system', content: getSystemPrompt('os', input) },
+                { role: 'system', content: sysPrompt },
                 ...sanitizedHistory
             ];
             const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
@@ -119,16 +161,15 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                 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 });
+            // P1: Capture <think> blocks for scratchpad, get clean content
+            const cleanedContent = scratchpad.capture(responseMessage.content || '', turnCount);
             exports.logger.addEntry({
                 role: 'assistant',
-                content: responseMessage.content || "",
+                content: cleanedContent || '',
                 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, '');
-                finalContent = finalContent.trim();
-                return finalContent;
+                return cleanedContent || 'No response generated.';
             }
             let canFastReturnAll = true;
             let accumulatedResults = [];
@@ -205,8 +246,26 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                     canFastReturnAll = false;
                 }
             }
-            // V2 Optimization (Expanded in v1.7.4): Zero-LLM Fast Return for data-heavy and read-only tools
-            // If all tools already return perfectly formatted markdown, skip the second LLM call to save 5-10s latency!
+            // P4: Self-reflection — if ALL tools failed, inject reflection before next turn
+            const allFailed = accumulatedResults.length > 0 && accumulatedResults.every(r => r.startsWith('Error') || r.includes('[System Error]') || r.includes('[Security Blocked]'));
+            if (allFailed) {
+                consecutiveToolErrors++;
+                const reflection = `[SELF-REFLECTION] All ${accumulatedResults.length} tool call(s) failed (attempt ${consecutiveToolErrors}). ` +
+                    `Errors: ${accumulatedResults.join(' | ')}. ` +
+                    `Analyze WHY each failed. Options: (1) retry with corrected params, (2) use alternative tool, (3) inform user clearly. ` +
+                    `Do NOT repeat the exact same failed call.`;
+                exports.logger.addEntry({ role: 'system', content: reflection }, sessionId);
+                console.log(picocolors_1.default.magenta(`[Self-Reflection] Turn ${turnCount}: all tools failed, injecting reflection.`));
+                if (consecutiveToolErrors >= 2) {
+                    const errorSummary = `⚠️ Unable to complete this request after multiple attempts.\n${accumulatedResults.join('\n')}`;
+                    exports.logger.addEntry({ role: 'assistant', content: errorSummary }, sessionId);
+                    return errorSummary;
+                }
+            }
+            else {
+                consecutiveToolErrors = 0;
+            }
+            // V2 Optimization: Zero-LLM Fast Return for transaction tools
             if (canFastReturnAll && accumulatedResults.length > 0) {
                 const finalContent = accumulatedResults.join('\n\n---\n\n');
                 exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
@@ -229,3 +288,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: await 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;
+    }
+}