nyxora 26.6.23 → 26.6.24

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

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cronManager = void 0;
-const cron = __importStar(require("node-cron"));
+const croner_1 = require("croner");
 const parser_1 = require("../config/parser");
 const telegram_1 = require("../gateway/telegram");
 const crypto_1 = require("crypto");
@@ -47,10 +47,13 @@ class CronManager {
     addJob(expression, prompt) {
         const id = (0, crypto_1.randomUUID)();
         // Validate expression
-        if (!cron.validate(expression)) {
+        try {
+            new croner_1.Cron(expression);
+        }
+        catch (e) {
             throw new Error(`Invalid cron expression: ${expression}`);
         }
-        const task = cron.schedule(expression, async () => {
+        const task = new croner_1.Cron(expression, async () => {
             console.log(picocolors_1.default.cyan(`[Cron] Executing job ${id}: "${prompt}"`));
             try {
                 // Dynamically import processUserInput to avoid circular dependencies

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

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiAdapter = exports.AnthropicAdapter = exports.OpenAIAdapter = void 0;
+const genai_1 = require("@google/genai");
+class OpenAIAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        const response = await this.client.chat.completions.create(request);
+        return {
+            message: {
+                content: response.choices[0].message.content,
+                tool_calls: response.choices[0].message.tool_calls
+            }
+        };
+    }
+}
+exports.OpenAIAdapter = OpenAIAdapter;
+class AnthropicAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        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 (e) { }
+                    });
+                }
+                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
+                        }
+                    ]
+                });
+            }
+        }
+        // Merge consecutive roles (Anthropic strictly requires alternating user/assistant)
+        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 if (typeof last.content === 'string' && Array.isArray(m.content)) {
+                    last.content = [{ type: 'text', text: last.content }, ...m.content];
+                }
+            }
+            else {
+                mergedAnthropic.push(m);
+            }
+        }
+        let anthropicTools = undefined;
+        if (request.tools) {
+            anthropicTools = request.tools.map(t => ({
+                name: t.function.name,
+                description: t.function.description,
+                input_schema: t.function.parameters
+            }));
+        }
+        const response = await this.client.messages.create({
+            model: request.model,
+            system: systemPrompt,
+            messages: mergedAnthropic,
+            tools: anthropicTools,
+            temperature: request.temperature,
+            max_tokens: request.max_tokens || 4096
+        });
+        let contentStr = null;
+        let toolCalls = [];
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                contentStr = (contentStr || '') + block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: {
+                        name: block.name,
+                        arguments: JSON.stringify(block.input)
+                    }
+                });
+            }
+        }
+        return {
+            message: {
+                content: contentStr,
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+            }
+        };
+    }
+}
+exports.AnthropicAdapter = AnthropicAdapter;
+class GeminiAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        let systemInstruction = '';
+        const rawGemini = [];
+        for (const m of request.messages) {
+            if (m.role === 'system') {
+                systemInstruction = m.content;
+                continue;
+            }
+            if (m.role === 'user') {
+                rawGemini.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 (e) { }
+                    });
+                }
+                rawGemini.push({ role: 'model', parts: parts });
+            }
+            else if (m.role === 'tool') {
+                rawGemini.push({
+                    role: 'user',
+                    parts: [{
+                            functionResponse: {
+                                name: m.name || 'unknown_tool',
+                                response: { result: m.content }
+                            }
+                        }]
+                });
+            }
+        }
+        const geminiMessages = [];
+        for (const m of rawGemini) {
+            const last = geminiMessages[geminiMessages.length - 1];
+            if (last && last.role === m.role) {
+                last.parts.push(...m.parts);
+            }
+            else {
+                geminiMessages.push(m);
+            }
+        }
+        let tools = undefined;
+        if (request.tools) {
+            tools = [{
+                    functionDeclarations: request.tools.map(t => ({
+                        name: t.function.name,
+                        description: t.function.description,
+                        parameters: t.function.parameters
+                    }))
+                }];
+        }
+        const response = await this.client.models.generateContent({
+            model: request.model,
+            contents: geminiMessages,
+            config: {
+                systemInstruction: systemInstruction,
+                tools: tools,
+                temperature: request.temperature,
+                safetySettings: [
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE },
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE },
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE },
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE }
+                ]
+            }
+        });
+        let contentStr = null;
+        let toolCalls = [];
+        if (response.candidates && response.candidates.length > 0) {
+            const candidate = response.candidates[0];
+            // Log finish reason for debugging safety blocks
+            if (candidate.finishReason && candidate.finishReason !== 'STOP') {
+                console.warn(`[LLM] Gemini API returned finishReason: ${candidate.finishReason}`);
+            }
+            if (candidate.content && candidate.content.parts) {
+                const parts = candidate.content.parts;
+                for (const part of parts) {
+                    if (part.text) {
+                        contentStr = (contentStr || '') + 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)
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            message: {
+                content: contentStr,
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+            }
+        };
+    }
+}
+exports.GeminiAdapter = GeminiAdapter;

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

@@ -0,0 +1,389 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.getOpenAI = getOpenAI;
+exports.processOsIntent = processOsIntent;
+const openai_1 = require("openai");
+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 updateProfile_1 = require("./updateProfile");
+const updateIdentity_1 = require("./updateIdentity");
+const updateSecurityPolicy_1 = require("../system/skills/updateSecurityPolicy");
+const analyzeDocument_1 = require("../system/skills/analyzeDocument");
+const readFile_1 = require("../system/skills/readFile");
+const writeFile_1 = require("../system/skills/writeFile");
+const generateExcel_1 = require("../system/skills/generateExcel");
+const executeShell_1 = require("../system/skills/executeShell");
+const browseWeb_1 = require("../system/skills/browseWeb");
+const searchWeb_1 = require("../system/skills/searchWeb");
+const editFile_1 = require("../system/skills/editFile");
+const gitManager_1 = require("../system/skills/gitManager");
+const xManager_1 = require("../system/skills/xManager");
+const notionWorkspace_1 = require("../system/skills/notionWorkspace");
+const audioTranscribe_1 = require("../system/skills/audioTranscribe");
+const summarizeText_1 = require("../system/skills/summarizeText");
+const scheduleTask_1 = require("../system/skills/scheduleTask");
+const cancelTask_1 = require("../system/skills/cancelTask");
+const googleWorkspace_1 = require("../system/skills/googleWorkspace");
+const picocolors_1 = __importDefault(require("picocolors"));
+exports.logger = new logger_1.Logger();
+const PROVIDER_CONFIGS = {
+    ollama: { baseURL: process.env.OLLAMA_BASE_URL ? `${process.env.OLLAMA_BASE_URL}/v1` : 'http://localhost:11434/v1', requiresApiKey: false },
+    gemini: { baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/', requiresApiKey: true },
+    openrouter: { baseURL: 'https://openrouter.ai/api/v1', requiresApiKey: true },
+    groq: { baseURL: 'https://api.groq.com/openai/v1', requiresApiKey: true },
+    mistral: { baseURL: 'https://api.mistral.ai/v1', requiresApiKey: true },
+    xai: { baseURL: 'https://api.x.ai/v1', requiresApiKey: true },
+    deepseek: { baseURL: 'https://api.deepseek.com', requiresApiKey: true },
+    openai: { requiresApiKey: true }
+};
+async function getOpenAI() {
+    const config = (0, parser_1.loadConfig)();
+    const vaultKeys = await (0, parser_1.loadApiKeys)();
+    const providerName = config.llm.provider || 'openai';
+    const providerConf = PROVIDER_CONFIGS[providerName] || PROVIDER_CONFIGS['openai'];
+    let apiKey = 'local';
+    if (providerConf.requiresApiKey) {
+        apiKey = '';
+        const keyName = `${providerName}_key`;
+        apiKey = vaultKeys[keyName] || config.credentials?.[keyName] || '';
+        if (!apiKey) {
+            throw new Error(`[Security] No API Key found for ${providerName} in OS Keyring. Please run 'nyxora set-key ${providerName} <key>' or 'nyxora setup'.`);
+        }
+        console.log(`[LLM] Using API Key securely unlocked from OS Keyring vault.`);
+    }
+    return new openai_1.OpenAI({
+        baseURL: providerConf.baseURL,
+        apiKey: apiKey,
+        timeout: 120 * 1000,
+        maxRetries: 0
+    });
+}
+async function executeWithRetry(requestBuilder, maxRetries = 3) {
+    let retries = 0;
+    while (retries <= maxRetries) {
+        try {
+            const client = await getOpenAI();
+            return await requestBuilder(client);
+        }
+        catch (error) {
+            const status = error?.status || error?.response?.status;
+            // 401 Unauthorized or 400 Bad Request - don't retry, it's fatal
+            if (status === 401 || status === 400) {
+                console.error(`[LLM] Fatal Error ${status}: ${error.message}. Aborting.`);
+                throw error;
+            }
+            // 429 Rate Limit - rotate provider/key immediately and retry
+            if (status === 429) {
+                console.warn(`[LLM] Rate Limit (429) hit. Rotating key...`);
+                // getOpenAI() automatically rotates to next key if available
+                retries++;
+                if (retries > maxRetries)
+                    throw error;
+                continue; // Try next key immediately
+            }
+            // 500, 502, 503, Timeout, Network error - Exponential Backoff
+            retries++;
+            if (retries > maxRetries) {
+                console.error(`[LLM] Max retries reached.`);
+                throw error;
+            }
+            const delayMs = Math.pow(2, retries) * 1000; // 2s, 4s, 8s
+            console.warn(`[LLM] API Error (${status || error.message}). Retrying in ${delayMs}ms...`);
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+        }
+    }
+}
+function getSystemPrompt(context = 'os') {
+    const config = (0, parser_1.loadConfig)();
+    const currentDateTime = new Date().toLocaleString('id-ID', { timeZone: 'Asia/Jakarta' });
+    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.
+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.`;
+    // Inject Episodic Memories
+    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)}%)
+`;
+            });
+        }
+    }
+    catch (error) { }
+    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 = [];
+    const SYSTEM_TOOLS = [updateProfile_1.updateProfileToolDefinition, updateIdentity_1.updateIdentityToolDefinition, updateSecurityPolicy_1.updateSecurityPolicyToolDefinition, analyzeDocument_1.analyzeDocumentToolDefinition, readFile_1.readLocalFileToolDefinition, writeFile_1.writeLocalFileToolDefinition, generateExcel_1.generateExcelToolDefinition, executeShell_1.runTerminalCommandToolDefinition, browseWeb_1.browseWebsiteToolDefinition, searchWeb_1.searchWebToolDefinition, editFile_1.editLocalFileToolDefinition, gitManager_1.gitManagerToolDefinition, xManager_1.xManagerToolDefinition, notionWorkspace_1.notionWorkspaceToolDefinition, audioTranscribe_1.audioTranscribeToolDefinition, summarizeText_1.summarizeTextToolDefinition, scheduleTask_1.scheduleTaskDefinition, cancelTask_1.cancelTaskDefinition];
+    const GOOGLE_TOOLS = [googleWorkspace_1.readGmailInboxToolDefinition, googleWorkspace_1.listCalendarEventsToolDefinition, googleWorkspace_1.appendRowToSheetsToolDefinition, googleWorkspace_1.readGoogleDocsToolDefinition, googleWorkspace_1.readGoogleFormResponsesToolDefinition];
+    activeTools = [...SYSTEM_TOOLS, ...GOOGLE_TOOLS].filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
+    const { sanitizeHistoryForLLM } = require('../utils/historySanitizer');
+    const sanitizedHistory = sanitizeHistoryForLLM(history, activeTools);
+    let messages = [
+        { role: 'system', content: getSystemPrompt('os') },
+        ...sanitizedHistory
+    ];
+    try {
+        const context = 'os';
+        const SYSTEM_TOOLS = [updateProfile_1.updateProfileToolDefinition, updateIdentity_1.updateIdentityToolDefinition, updateSecurityPolicy_1.updateSecurityPolicyToolDefinition, analyzeDocument_1.analyzeDocumentToolDefinition, readFile_1.readLocalFileToolDefinition, writeFile_1.writeLocalFileToolDefinition, generateExcel_1.generateExcelToolDefinition, executeShell_1.runTerminalCommandToolDefinition, browseWeb_1.browseWebsiteToolDefinition, searchWeb_1.searchWebToolDefinition, editFile_1.editLocalFileToolDefinition, gitManager_1.gitManagerToolDefinition, xManager_1.xManagerToolDefinition, notionWorkspace_1.notionWorkspaceToolDefinition, audioTranscribe_1.audioTranscribeToolDefinition, summarizeText_1.summarizeTextToolDefinition, scheduleTask_1.scheduleTaskDefinition, cancelTask_1.cancelTaskDefinition];
+        const GOOGLE_TOOLS = [googleWorkspace_1.readGmailInboxToolDefinition, googleWorkspace_1.listCalendarEventsToolDefinition, googleWorkspace_1.appendRowToSheetsToolDefinition, googleWorkspace_1.readGoogleDocsToolDefinition, googleWorkspace_1.readGoogleFormResponsesToolDefinition];
+        let activeTools = [...SYSTEM_TOOLS, ...GOOGLE_TOOLS];
+        activeTools = activeTools.filter(t => (0, skillManager_1.isSkillActive)(t.function.name));
+        const response = await executeWithRetry(async (client) => {
+            return await client.chat.completions.create({
+                model: config.llm.model,
+                temperature: config.llm.temperature,
+                messages: messages,
+                tools: activeTools,
+                tool_choice: "auto",
+            });
+        });
+        const responseMessage = response.choices[0].message;
+        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 canFastReturnAll = true;
+            let accumulatedResults = [];
+            // Enabled fastReturnTools to eliminate 2nd LLM latency for transaction popups
+            const fastReturnTools = [
+                'transfer_token', 'transfer_native', 'swap_token', 'bridge_token',
+                'mint_nft', 'custom_tx', 'revoke_approval', 'supply_aave',
+                'deposit_yield_vault', 'provide_liquidity_v3'
+            ];
+            for (const _toolCall of responseMessage.tool_calls) {
+                const toolCall = _toolCall;
+                let result = "";
+                let args = {};
+                const toolName = toolCall.function.name;
+                console.log(picocolors_1.default.yellow(`[⚡ Tool Execution] AI is calling ${toolName}...`));
+                if (onProgress)
+                    onProgress(`_⚡ Running tool: ${toolName}..._`);
+                try {
+                    args = JSON.parse(toolCall.function.arguments);
+                }
+                catch (parseError) {
+                    console.error(picocolors_1.default.red(`[LLM Validation Error] Invalid JSON arguments for ${toolName}: ${parseError.message}`));
+                    result = `[System Error] Arguments for ${toolName} must be valid JSON. Please correct the format. Error: ${parseError.message}`;
+                    exports.logger.addEntry({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: result
+                    }, sessionId);
+                    continue;
+                }
+                if (!(0, skillManager_1.isSkillActive)(toolName)) {
+                    console.warn(picocolors_1.default.red(`[Security] Blocked illegal execution of disabled skill: ${toolName}`));
+                    result = `[System Error] Access denied: Skill '${toolName}' is currently disabled by the user.`;
+                    exports.logger.addEntry({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: result
+                    }, sessionId);
+                    continue;
+                }
+                try {
+                    switch (toolName) {
+                        case 'update_profile': {
+                            result = (0, updateProfile_1.updateProfile)(args.content, args.mode);
+                            break;
+                        }
+                        case 'update_identity': {
+                            result = (0, updateIdentity_1.updateIdentity)(args.content, args.mode);
+                            break;
+                        }
+                        case 'update_security_policy': {
+                            result = await (0, updateSecurityPolicy_1.updateSecurityPolicy)(args.policy, args.action || 'add');
+                            break;
+                        }
+                        case 'analyze_document': {
+                            result = await (0, analyzeDocument_1.analyzeDocument)(args.filePath);
+                            break;
+                        }
+                        case 'read_local_file': {
+                            result = (0, readFile_1.readLocalFile)(args.filePath, args.startLine, args.endLine);
+                            break;
+                        }
+                        case 'edit_local_file': {
+                            result = (0, editFile_1.editLocalFile)(args.filePath, args.searchString, args.replacementString);
+                            break;
+                        }
+                        case 'execute_git_command': {
+                            result = await (0, gitManager_1.executeGitCommand)(args.action, args.commitMessage);
+                            break;
+                        }
+                        case 'manage_twitter': {
+                            result = await (0, xManager_1.manageTwitter)(args.action, args.content, args.username);
+                            break;
+                        }
+                        case 'manage_notion': {
+                            result = await (0, notionWorkspace_1.manageNotion)(args.action, args.pageId, args.text);
+                            break;
+                        }
+                        case 'transcribe_audio': {
+                            result = await (0, audioTranscribe_1.transcribeAudio)(args.filePath);
+                            break;
+                        }
+                        case 'summarize_text': {
+                            result = await (0, summarizeText_1.summarizeText)(args.text, args.focus);
+                            break;
+                        }
+                        case 'write_local_file': {
+                            result = (0, writeFile_1.writeLocalFile)(args.filePath, args.content);
+                            break;
+                        }
+                        case 'generate_excel_file': {
+                            result = await (0, generateExcel_1.generateExcelFile)(args.data, args.filePath);
+                            break;
+                        }
+                        case 'run_terminal_command': {
+                            result = await (0, executeShell_1.runTerminalCommand)(args.command);
+                            break;
+                        }
+                        case 'browse_website': {
+                            result = await (0, browseWeb_1.browseWebsite)(args.url);
+                            break;
+                        }
+                        case 'search_web': {
+                            result = await (0, searchWeb_1.searchWeb)(args.query, args.depth);
+                            break;
+                        }
+                        case 'schedule_task': {
+                            result = await (0, scheduleTask_1.executeScheduleTask)(args);
+                            break;
+                        }
+                        case 'cancel_task': {
+                            result = await (0, cancelTask_1.executeCancelTask)(args);
+                            break;
+                        }
+                        case 'read_gmail_inbox': {
+                            result = await (0, googleWorkspace_1.readGmailInbox)(args.maxResults);
+                            break;
+                        }
+                        case 'list_calendar_events': {
+                            result = await (0, googleWorkspace_1.listCalendarEvents)(args.maxResults);
+                            break;
+                        }
+                        case 'append_row_to_sheets': {
+                            result = await (0, googleWorkspace_1.appendRowToSheets)(args.spreadsheetId, args.range, args.values);
+                            break;
+                        }
+                        case 'read_google_docs': {
+                            result = await (0, googleWorkspace_1.readGoogleDocs)(args.documentId);
+                            break;
+                        }
+                        case 'read_google_form_responses': {
+                            result = await (0, googleWorkspace_1.readGoogleFormResponses)(args.formId);
+                            break;
+                        }
+                        default: {
+                            result = `Error: Tool ${toolName} is not implemented.`;
+                            break;
+                        }
+                    }
+                    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 completely: ${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;
+                }
+            }
+            // 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!
+            if (canFastReturnAll && accumulatedResults.length > 0) {
+                const finalContent = accumulatedResults.join('\n\n---\n\n');
+                exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
+                return finalContent;
+            }
+            // Second call to get the final answer after tool execution
+            const secondSanitized = sanitizeHistoryForLLM(exports.logger.getHistory(sessionId), activeTools);
+            const secondMessages = [
+                { role: 'system', content: getSystemPrompt('os') },
+                ...secondSanitized
+            ];
+            const secondResponse = await executeWithRetry(async (client) => {
+                return await client.chat.completions.create({
+                    model: config.llm.model,
+                    messages: secondMessages,
+                });
+            });
+            if (secondResponse.usage?.total_tokens) {
+                tracker_1.Tracker.addTokens(secondResponse.usage.total_tokens, config.llm.provider);
+            }
+            tracker_1.Tracker.addEvent('llm.final_response', { provider: config.llm.provider });
+            let finalContent = secondResponse.choices[0].message.content || "";
+            // Clean up orphaned <think> blocks that forgot to output </think>
+            finalContent = finalContent.replace(/<thought>[\s\S]*?<\/thought>\n?/gi, '');
+            finalContent = finalContent.replace(/<think>[\s\S]*?<\/think>\n?/gi, '');
+            if (finalContent.includes('<think>')) {
+                finalContent = finalContent.replace(/<think>[\s\S]*?\n\n/i, '');
+                finalContent = finalContent.replace(/<think>[\s\S]*$/i, '');
+            }
+            finalContent = finalContent.trim();
+            exports.logger.addEntry({ role: 'assistant', content: finalContent }, sessionId);
+            return finalContent;
+        }
+        let finalContent = responseMessage.content || "No response generated.";
+        // Clean up orphaned <think> blocks that forgot to output </think>
+        finalContent = finalContent.replace(/<thought>[\s\S]*?<\/thought>\n?/gi, '');
+        finalContent = finalContent.replace(/<think>[\s\S]*?<\/think>\n?/gi, '');
+        if (finalContent.includes('<think>')) {
+            finalContent = finalContent.replace(/<think>[\s\S]*?\n\n/i, '');
+            finalContent = finalContent.replace(/<think>[\s\S]*$/i, '');
+        }
+        finalContent = finalContent.trim();
+        return finalContent;
+    }
+    catch (error) {
+        console.error("LLM Error:", error);
+        const errorMsg = '⚠️ All models are temporarily rate-limited. Please try again in a few minutes.';
+        exports.logger.addEntry({ role: 'assistant', content: errorMsg }, sessionId);
+        return errorMsg;
+    }
+}