nyxora 26.7.3 → 26.7.5

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

@@ -6,118 +6,110 @@ 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.
-Do NOT stop early if another tool call would materially improve the result.
-Continue using tools until the task is completely finished and verified.
-</tool_persistence>
-
-<mandatory_tool_use>
-NEVER answer the following using only your internal memory — ALWAYS use the relevant tool:
-- Arithmetic, math, calculations
-- System State: OS version, RAM, processes
-- File contents, file sizes
-- Real-world current events
-</mandatory_tool_use>
-
-<act_dont_ask>
-When a user's request has a clear, standard interpretation, take immediate ACTION instead of asking for clarification.
-</act_dont_ask>
-
-<task_completion>
-The deliverable must be a working artifact backed by real tool output — not just a description or a plan of how you would do it.
-NEVER fabricate, hallucinate, or forge tool outputs.
-</task_completion>
-`;
+const promptBuilder_1 = require("./promptBuilder");
 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");
-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).
-The current real-world date and time is: ${currentDateTime}.
-
-Reason internally. Never reveal private reasoning. Provide only concise conclusions, assumptions, and actionable steps.
-
-[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, 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.
-
-${EXECUTION_DISCIPLINE}
-`;
-    // Inject Active Cognitive Skills
-    const activeSOP = cognitiveManager_1.cognitiveManager.loadActiveCognitiveSkills(userInput);
-    if (activeSOP) {
-        basePrompt += `\n\n[ACTIVE COGNITIVE SKILLS]\n${activeSOP}\n`;
-    }
-    // Inject Episodic Memories via Python RAG
-    try {
-        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`;
-                });
+// --- REGISTER LIFECYCLE HOOKS ---
+registry_1.pluginManager.registerHook({
+    name: 'ReasoningGate',
+    beforeToolCall: async (toolName, args, context) => {
+        const toolsRequiringReasoning = ['run_command', 'write_to_file', 'replace_file_content', 'multi_replace_file_content', 'execute_script'];
+        if (toolsRequiringReasoning.includes(toolName)) {
+            const responseMessage = context.responseMessage || {};
+            const hasThinkingTag = /<(think|thought|thinking|reasoning|analysis|reflection)>[\s\S]*?<\/\1>/i.test(responseMessage.content || '');
+            const hasNativeReasoning = !!responseMessage.reasoning_content;
+            if (!hasThinkingTag && !hasNativeReasoning) {
+                const msg = `[System Error] BLOCKED BY REASONING GATE: You MUST output a <think>...</think> block to plan your actions BEFORE calling the '${toolName}' tool. Please rethink and try again.`;
+                console.log(picocolors_1.default.red(`[❌ Blocked] Tool ${toolName} blocked by Reasoning Gate.`));
+                return { block: true, reason: msg };
             }
         }
     }
-    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`;
+});
+registry_1.pluginManager.registerHook({
+    name: 'Web3FastReturn',
+    afterToolCall: async (toolName, args, result, context) => {
+        const fastReturnTools = ['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3', 'send_telegram_file'];
+        if (fastReturnTools.includes(toolName)) {
+            return { terminate: true };
         }
     }
-    catch (e) {
-        // Ignore error
-    }
-    // HIGHEST PRIORITY: Inject observed user communication style (NyxDaemon)
+});
+// --- END LIFECYCLE HOOKS ---
+exports.logger = new logger_1.Logger();
+// Helper to trigger background review async
+const triggerBackgroundReview = async (sessionId) => {
     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`;
-            });
-        }
+        const history = exports.logger.getHistory(sessionId, 30);
+        fetch('http://127.0.0.1:8000/cognitive/review', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                messages: history,
+                session_id: sessionId || 'default',
+                trigger: 'turn_end'
+            })
+        }).catch(() => { });
     }
     catch (e) {
-        // Ignore
+        // silently fail
     }
-    return basePrompt;
+};
+const llmUtils_1 = require("../utils/llmUtils");
+async function getSystemPrompt(context = 'os', userInput = '') {
+    const config = (0, parser_1.loadConfig)();
+    // Safely deduce model family from config
+    const provider = (config?.llm?.provider || '').toLowerCase();
+    let modelFamily = 'unknown';
+    if (provider.includes('openai'))
+        modelFamily = 'openai';
+    else if (provider.includes('gemini') || provider.includes('google'))
+        modelFamily = 'google';
+    else if (provider.includes('anthropic') || provider.includes('claude'))
+        modelFamily = 'anthropic';
+    else if (provider.includes('grok') || provider.includes('xai'))
+        modelFamily = 'grok';
+    return await promptBuilder_1.promptBuilder.buildSystemPrompt({
+        agentType: context,
+        userInput,
+        config,
+        modelFamily
+    });
 }
 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);
+    // --- MULTILINGUAL USER CORRECTION DETECTION ---
+    const correctionSignals = [
+        // ID
+        'salah', 'ngawur', 'keliru', 'bukan', 'tidak benar', 'perbaiki', 'coba lagi',
+        // EN
+        'wrong', 'incorrect', 'mistake', 'not right', 'false', 'bad', 'fix', 'try again',
+        // ES & FR
+        'incorrecto', 'mal', 'equivocado', 'error', 'falso', 'faux', 'erreur', 'mauvais',
+        // DE & RU
+        'falsch', 'inkorrekt', 'fehler', 'ошибка', 'неправильно', 'неверно',
+        // JP & ZH
+        '違う', '間違い', 'やり直して', '错误', '不对'
+    ];
+    if (role === 'user' && correctionSignals.some(s => input.toLowerCase().includes(s))) {
+        exports.logger.addEntry({
+            role: 'system',
+            content: `[USER CORRECTION DETECTED] The user indicated your previous answer was WRONG, STALE, or INACCURATE.
+CRITICAL INSTRUCTIONS:
+1. Do NOT just apologize and repeat the same data from your memory.
+2. The data in your training memory or previous tool calls is likely stale/incorrect.
+3. You MUST call a tool (like search_web or others) NOW to verify the facts with FRESH data.
+4. Base your new answer strictly on the NEW tool results.`
+        }, sessionId);
+    }
     let activeTools = [...registry_1.pluginManager.getAllToolDefinitions()];
     activeTools = activeTools.filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
     // P1: Init reasoning scratchpad for this request
@@ -129,6 +121,7 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
         let turnCount = 0;
         const MAX_TURNS = 10;
         let consecutiveToolErrors = 0;
+        let criticHasFired = false; // Critic Pass hanya aktif 1x per request
         while (turnCount < MAX_TURNS) {
             turnCount++;
             const currentHistory = exports.logger.getHistory(sessionId);
@@ -150,7 +143,8 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                     model: config.llm.model,
                     temperature: config.llm.temperature,
                     messages: messages,
-                    tools: activeTools
+                    tools: activeTools,
+                    reasoning_effort: (!config.llm.reasoning_effort || config.llm.reasoning_effort === 'none') ? undefined : config.llm.reasoning_effort
                 });
             });
             const responseMessage = response.message;
@@ -169,6 +163,10 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                 tool_calls: responseMessage.tool_calls,
             }, sessionId);
             if (!responseMessage.tool_calls || responseMessage.tool_calls.length === 0) {
+                // --- CRITIC PASS REMOVED ---
+                // The new PromptBuilder handles robust reasoning. Post-generation critic
+                // causes aggressive loops and UI artifacts.
+                triggerBackgroundReview(sessionId);
                 return cleanedContent || 'No response generated.';
             }
             let canFastReturnAll = true;
@@ -177,7 +175,7 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
             const fastReturnTools = [
                 'transfer_token', 'transfer_native', 'swap_token', 'bridge_token',
                 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave',
-                'deposit_yield_vault', 'provide_liquidity_v3'
+                'deposit_yield_vault', 'provide_liquidity_v3', 'send_telegram_file'
             ];
             for (const _toolCall of responseMessage.tool_calls) {
                 const toolCall = _toolCall;
@@ -242,7 +240,7 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                     content: result,
                 }, sessionId);
                 accumulatedResults.push(result);
-                if (!fastReturnTools.includes(toolName)) {
+                if (!['transfer_token', 'transfer_native', 'swap_token', 'bridge_token', 'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave', 'deposit_yield_vault', 'provide_liquidity_v3', 'send_telegram_file'].includes(toolName)) {
                     canFastReturnAll = false;
                 }
             }
@@ -259,6 +257,7 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
                 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);
+                    triggerBackgroundReview(sessionId);
                     return errorSummary;
                 }
             }
@@ -269,12 +268,14 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
             if (canFastReturnAll && accumulatedResults.length > 0) {
                 const finalContent = accumulatedResults.join('\n\n---\n\n');
                 exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
+                triggerBackgroundReview(sessionId);
                 return finalContent;
             }
             // Loop continues, sending tool results in the next turn
         }
         const maxTurnMsg = "⚠️ Reached maximum interaction limit (10 turns). Please be more specific.";
         exports.logger.addEntry({ role: 'assistant', content: maxTurnMsg }, sessionId);
+        triggerBackgroundReview(sessionId);
         return maxTurnMsg;
     }
     catch (error) {
@@ -291,6 +292,30 @@ async function processOsIntent(input, role = 'user', onProgress, sessionId) {
 async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
     const config = (0, parser_1.loadConfig)();
     exports.logger.addEntry({ role: 'user', content: input }, sessionId);
+    // --- MULTILINGUAL USER CORRECTION DETECTION ---
+    const correctionSignals = [
+        // ID
+        'salah', 'ngawur', 'keliru', 'bukan', 'tidak benar', 'perbaiki', 'coba lagi',
+        // EN
+        'wrong', 'incorrect', 'mistake', 'not right', 'false', 'bad', 'fix', 'try again',
+        // ES & FR
+        'incorrecto', 'mal', 'equivocado', 'error', 'falso', 'faux', 'erreur', 'mauvais',
+        // DE & RU
+        'falsch', 'inkorrekt', 'fehler', 'ошибка', 'неправильно', 'неверно',
+        // JP & ZH
+        '違う', '間違い', 'やり直して', '错误', '不对'
+    ];
+    if (correctionSignals.some(s => input.toLowerCase().includes(s))) {
+        exports.logger.addEntry({
+            role: 'system',
+            content: `[USER CORRECTION DETECTED] The user indicated your previous answer was WRONG, STALE, or INACCURATE.
+CRITICAL INSTRUCTIONS:
+1. Do NOT just apologize and repeat the same data from your memory.
+2. The data in your training memory or previous tool calls is likely stale/incorrect.
+3. You MUST call a tool (like search_web or others) NOW to verify the facts with FRESH data.
+4. Base your new answer strictly on the NEW tool results.`
+        }, sessionId);
+    }
     const pluginTools = registry_1.pluginManager.getAllToolDefinitions();
     let activeTools = [...pluginTools].filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
     const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
@@ -298,6 +323,7 @@ async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
         let turnCount = 0;
         const MAX_TURNS = 10;
         let fullResponse = '';
+        let criticHasFiredStream = false; // Critic Pass hanya aktif 1x per request
         while (turnCount < MAX_TURNS) {
             turnCount++;
             const currentHistory = exports.logger.getHistory(sessionId);
@@ -308,7 +334,9 @@ async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
             ];
             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 = '';
+                onChunk('[CLEAR_STREAM]');
+                return await client.stream({ model: config.llm.model, temperature: config.llm.temperature, messages, tools: activeTools, reasoning_effort: (!config.llm.reasoning_effort || config.llm.reasoning_effort === 'none') ? undefined : config.llm.reasoning_effort }, (chunk) => {
                     streamedContent += chunk;
                     onChunk(chunk);
                 });
@@ -322,23 +350,28 @@ async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
             exports.logger.addEntry({
                 role: 'assistant',
                 content: responseMessage.content || '',
+                reasoning_content: responseMessage.reasoning_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();
+                finalContent = finalContent.replace(/^\s*(?:\*\*)?(?:think|thought|thinking|reasoning|analysis|reflection)(?:\*\*)?\s*?\n[\s\S]*?\n\n/i, '').trim();
+                // --- CRITIC PASS REMOVED ---
+                // Prevents leaking internal reasoning into the stream and confusing the user.
                 fullResponse = finalContent;
+                triggerBackgroundReview(sessionId);
                 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;
+            // Tool calls detected — pause stream visually and execute tools concurrently
+            let shouldFastReturn = false;
             const accumulatedResults = [];
-            for (const _toolCall of responseMessage.tool_calls) {
+            const promises = responseMessage.tool_calls.map(async (_toolCall) => {
                 const toolCall = _toolCall;
                 const toolName = toolCall.function.name;
                 let result = '';
                 let args = {};
+                const context = { sessionId, toolCallId: toolCall.id, responseMessage };
                 console.log(picocolors_1.default.yellow(`[⚡ Tool Execution] AI is calling ${toolName}...`));
                 if (onProgress)
                     onProgress(`_⚡ Running tool: ${toolName}..._`);
@@ -351,17 +384,28 @@ async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
                 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;
+                    return { toolName, result };
                 }
                 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;
+                    return { toolName, result };
+                }
+                // --- LIFECYCLE: BEFORE TOOL CALL ---
+                const beforeRes = await registry_1.pluginManager.triggerBeforeHooks(toolName, args, context);
+                if (beforeRes && beforeRes.block) {
+                    result = beforeRes.reason || `[System Error] Blocked by hook for ${toolName}`;
+                    exports.logger.addEntry({ role: 'tool', tool_call_id: toolCall.id, content: result }, sessionId);
+                    return { toolName, result };
                 }
                 try {
-                    const pluginResult = await registry_1.pluginManager.executeTool(toolName, args, { sessionId });
+                    const pluginResult = await registry_1.pluginManager.executeTool(toolName, args, context, (partialResult) => {
+                        // Partial Streaming callback
+                        if (onProgress)
+                            onProgress(`_⏳ [${toolName}] ${partialResult}..._`);
+                    });
                     result = pluginResult !== null ? pluginResult : `Error: Tool ${toolName} is not implemented.`;
-                    if (result.includes('[Security Blocked]') || result.startsWith('Error:')) {
+                    if (typeof result === 'string' && (result.includes('[Security Blocked]') || result.startsWith('Error:'))) {
                         console.log(picocolors_1.default.red(`[❌ Failed] Tool ${toolName} returned an error or was blocked.`));
                     }
                     else {
@@ -372,16 +416,23 @@ async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
                     result = `Error executing ${toolName}: ${toolError.message}`;
                     console.error(picocolors_1.default.red(`[❌ Error Crash] Execution of ${toolName} failed: ${toolError.message}`));
                 }
+                // --- LIFECYCLE: AFTER TOOL CALL ---
+                const afterRes = await registry_1.pluginManager.triggerAfterHooks(toolName, args, result, context);
+                result = afterRes.content || result;
+                if (afterRes.terminate) {
+                    shouldFastReturn = true;
+                }
                 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) {
+                return { toolName, result };
+            });
+            const results = await Promise.all(promises);
+            results.forEach(r => accumulatedResults.push(r.result));
+            if (shouldFastReturn && accumulatedResults.length > 0) {
                 const finalContent = accumulatedResults.join('\n\n---\n\n');
                 exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
                 onChunk(finalContent);
                 fullResponse = finalContent;
+                triggerBackgroundReview(sessionId);
                 break;
             }
         }
@@ -389,6 +440,7 @@ async function processOsIntentStream(input, onChunk, onProgress, sessionId) {
             const maxTurnMsg = '⚠️ Reached maximum interaction limit (10 turns). Please be more specific.';
             exports.logger.addEntry({ role: 'assistant', content: maxTurnMsg }, sessionId);
             fullResponse = maxTurnMsg;
+            triggerBackgroundReview(sessionId);
         }
         return fullResponse;
     }