nyxora 1.0.0

package/dist/gateway/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const open_1 = __importDefault(require("open"));
+const paths_1 = require("../config/paths");
+const server_1 = require("./server");
+// 1. Determine configuration directory
+const appDir = (0, paths_1.getAppDir)();
+const isGlobalMode = appDir !== process.cwd();
+console.log(`================================`);
+console.log(`🤖 Nyxora CLI Agent Booting Up...`);
+console.log(`📂 Config Directory: ${appDir}`);
+console.log(`================================`);
+// 2. Setup boilerplate files if in global mode and they don't exist
+if (isGlobalMode) {
+    const globalEnvPath = path_1.default.join(appDir, '.env');
+    const globalUserMdPath = path_1.default.join(appDir, 'user.md');
+    const globalIdentityMdPath = path_1.default.join(appDir, 'IDENTITY.md');
+    // Copy .env.example to ~/.nyxora/.env if it doesn't exist
+    if (!fs_1.default.existsSync(globalEnvPath)) {
+        const exampleEnvPath = path_1.default.resolve(__dirname, '../../../.env.example');
+        if (fs_1.default.existsSync(exampleEnvPath)) {
+            fs_1.default.copyFileSync(exampleEnvPath, globalEnvPath);
+            console.log(`[Setup] Created default .env at ${globalEnvPath}`);
+        }
+        else {
+            fs_1.default.writeFileSync(globalEnvPath, '# Nyxora Environment Variables\nOPENAI_API_KEY=\nGEMINI_API_KEY=\nTELEGRAM_BOT_TOKEN=\n');
+        }
+    }
+    if (!fs_1.default.existsSync(globalUserMdPath)) {
+        fs_1.default.writeFileSync(globalUserMdPath, 'Tuliskan instruksi kustom, aturan khusus, profil pengguna, atau persona yang Anda inginkan untuk Nyxora AI di file ini.\n');
+    }
+    if (!fs_1.default.existsSync(globalIdentityMdPath)) {
+        fs_1.default.writeFileSync(globalIdentityMdPath, 'Kamu adalah Nyxora, asisten Web3 pintar.\n');
+    }
+}
+// 3. Load Environment Variables from the determined directory
+dotenv.config({ path: path_1.default.join(appDir, '.env') });
+// 4. Start the Express API Server (which also serves the static dashboard and Telegram bot)
+(0, server_1.startServer)();
+// 5. Open the Dashboard in the default browser
+const PORT = process.env.PORT || 3000;
+setTimeout(() => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`🌐 Opening Dashboard at ${url}`);
+    (0, open_1.default)(url);
+}, 1500);

package/dist/gateway/server.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = __importDefault(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const paths_1 = require("../config/paths");
+dotenv.config({ path: (0, paths_1.getPath)('.env') });
+const reasoning_1 = require("../agent/reasoning");
+const parser_1 = require("../config/parser");
+const tracker_1 = require("./tracker");
+const getBalance_1 = require("../web3/skills/getBalance");
+const transfer_1 = require("../web3/skills/transfer");
+const getPrice_1 = require("../web3/skills/getPrice");
+const swapToken_1 = require("../web3/skills/swapToken");
+const telegram_1 = require("./telegram");
+// Intercept console.log and console.error
+const originalLog = console.log;
+const originalError = console.error;
+console.log = function (...args) {
+    tracker_1.Tracker.addGatewayLog(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '));
+    originalLog.apply(console, args);
+};
+console.error = function (...args) {
+    tracker_1.Tracker.addGatewayLog(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '), { level: 'error' });
+    originalError.apply(console, args);
+};
+const app = (0, express_1.default)();
+app.use((0, cors_1.default)());
+app.use(express_1.default.json());
+// Serve static frontend from dashboard/dist
+app.use(express_1.default.static(path_1.default.join(__dirname, '../../../dashboard/dist')));
+app.get('/api/history', (req, res) => {
+    try {
+        const history = reasoning_1.logger.getHistory();
+        // Filter out internal system prompt for the frontend
+        const cleanHistory = history.filter((msg) => msg.role !== 'system');
+        res.json(cleanHistory);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.delete('/api/history', (req, res) => {
+    try {
+        reasoning_1.logger.clear();
+        tracker_1.Tracker.addEvent('memory.cleared');
+        res.json({ success: true });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get('/api/config', (req, res) => {
+    try {
+        const config = (0, parser_1.loadConfig)();
+        res.json(config);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.post('/api/config', (req, res) => {
+    try {
+        // Save new configuration to file
+        (0, parser_1.saveConfig)(req.body);
+        tracker_1.Tracker.addEvent('config.updated', { provider: req.body.llm?.provider });
+        res.json({ success: true });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+app.get('/api/stats', (req, res) => {
+    res.json(tracker_1.Tracker.getStats());
+});
+app.get('/api/logs', (req, res) => {
+    res.json(tracker_1.Tracker.getLogs());
+});
+app.get('/api/skills', (req, res) => {
+    res.json([
+        getBalance_1.getBalanceToolDefinition,
+        transfer_1.transferToolDefinition,
+        getPrice_1.getPriceToolDefinition,
+        swapToken_1.swapTokenToolDefinition
+    ]);
+});
+app.post('/api/chat', async (req, res) => {
+    try {
+        const { message } = req.body;
+        if (!message) {
+            return res.status(400).json({ error: 'Message is required' });
+        }
+        // Process input (this will automatically add to memory)
+        const response = await (0, reasoning_1.processUserInput)(message);
+        res.json({ response });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// Fallback for React Router (Single Page Application)
+app.get('*', (req, res) => {
+    res.sendFile(path_1.default.join(__dirname, '../../../dashboard/dist/index.html'));
+});
+function startServer() {
+    const PORT = process.env.PORT || 3000;
+    app.listen(PORT, () => {
+        console.log(`🤖 Nyxora API Server running on port ${PORT}`);
+        // Start the Telegram bot listener
+        (0, telegram_1.startTelegramBot)();
+    });
+}
+// Start server if this file is run directly
+if (require.main === module) {
+    startServer();
+}

package/dist/gateway/telegram.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTelegramBot = startTelegramBot;
+const node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
+const reasoning_1 = require("../agent/reasoning");
+function startTelegramBot() {
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    if (!token) {
+        console.log('[Telegram] No TELEGRAM_BOT_TOKEN found in .env. Bot is disabled.');
+        return;
+    }
+    try {
+        const bot = new node_telegram_bot_api_1.default(token, { polling: true });
+        bot.on('message', async (msg) => {
+            const chatId = msg.chat.id;
+            const text = msg.text;
+            if (!text)
+                return;
+            // Log incoming message
+            console.log(`[Telegram] Received from ${msg.from?.first_name}: ${text}`);
+            // Send typing action to Telegram
+            bot.sendChatAction(chatId, 'typing');
+            try {
+                // Feed the message to the AI agent
+                const response = await (0, reasoning_1.processUserInput)(text);
+                // Send the AI's response back to Telegram
+                bot.sendMessage(chatId, response);
+            }
+            catch (error) {
+                console.error('[Telegram] Error processing message:', error);
+                bot.sendMessage(chatId, '❌ Maaf, saya mengalami gangguan saat memproses pesan Anda.');
+            }
+        });
+        bot.on('polling_error', (error) => {
+            console.error('[Telegram] Polling error:', error);
+        });
+        console.log('🤖 Telegram Bot is running and listening for messages...');
+    }
+    catch (error) {
+        console.error('[Telegram] Failed to initialize bot:', error);
+    }
+}

package/dist/gateway/test.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const reasoning_1 = require("../agent/reasoning");
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+async function run() {
+    console.log('🤖 Agent Test Started...');
+    console.log('👤 You: Tolong cek saldo native di jaringan ethereum');
+    try {
+        const response = await (0, reasoning_1.processUserInput)('Tolong cek saldo native di jaringan ethereum');
+        console.log(`\n🤖 Nyxora Agent: ${response}\n`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+    }
+}
+run();

package/dist/gateway/tracker.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracker = void 0;
+const stats = {
+    cost: 0,
+    tokens: 0,
+    messages: 0
+};
+const eventLogs = [];
+const gatewayLogs = [];
+const MAX_LOGS = 100;
+function formatTime() {
+    const now = new Date();
+    return now.toTimeString().split(' ')[0]; // Returns HH:MM:SS
+}
+exports.Tracker = {
+    addTokens: (amount, provider) => {
+        stats.tokens += amount;
+        // Simple mock cost calculation
+        let rate = 0;
+        if (provider === 'openai')
+            rate = 0.00002;
+        else if (provider === 'gemini')
+            rate = 0.00001;
+        stats.cost += (amount * rate);
+    },
+    addMessage: () => {
+        stats.messages += 1;
+    },
+    getStats: () => {
+        return { ...stats, cost: Number(stats.cost.toFixed(4)) };
+    },
+    addEvent: (event, meta = {}) => {
+        eventLogs.unshift({ timestamp: formatTime(), event, meta });
+        if (eventLogs.length > MAX_LOGS)
+            eventLogs.pop();
+    },
+    addGatewayLog: (message, meta) => {
+        gatewayLogs.unshift({ timestamp: formatTime(), message, meta });
+        if (gatewayLogs.length > MAX_LOGS)
+            gatewayLogs.pop();
+    },
+    getLogs: () => {
+        return {
+            events: eventLogs,
+            gateway: gatewayLogs
+        };
+    }
+};

package/dist/memory/logger.js

@@ -0,0 +1,50 @@
+"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;
+const fs_1 = __importDefault(require("fs"));
+const parser_1 = require("../config/parser");
+const paths_1 = require("../config/paths");
+class Logger {
+    logFilePath;
+    memory = [];
+    constructor() {
+        const config = (0, parser_1.loadConfig)();
+        this.logFilePath = (0, paths_1.getPath)(config.memory.path || 'memory.json');
+        this.loadMemory();
+    }
+    loadMemory() {
+        if (fs_1.default.existsSync(this.logFilePath)) {
+            try {
+                const data = fs_1.default.readFileSync(this.logFilePath, 'utf-8');
+                this.memory = JSON.parse(data);
+            }
+            catch (error) {
+                console.error('Failed to read memory file. Starting fresh.');
+                this.memory = [];
+            }
+        }
+    }
+    saveMemory() {
+        try {
+            fs_1.default.writeFileSync(this.logFilePath, JSON.stringify(this.memory, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to write memory file.');
+        }
+    }
+    getHistory() {
+        return [...this.memory];
+    }
+    addEntry(entry) {
+        this.memory.push(entry);
+        this.saveMemory();
+    }
+    clear() {
+        this.memory = [];
+        this.saveMemory();
+    }
+}
+exports.Logger = Logger;

package/dist/src/agent/reasoning.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUserInput = processUserInput;
+const openai_1 = require("openai");
+const parser_1 = require("../config/parser");
+const logger_1 = require("../memory/logger");
+const getBalance_1 = require("../web3/skills/getBalance");
+const config = (0, parser_1.loadConfig)();
+const logger = new logger_1.Logger();
+// Initialize OpenAI client
+const openai = new openai_1.OpenAI({
+    apiKey: process.env.OPENAI_API_KEY,
+});
+const systemPrompt = `You are an autonomous Web3 agent operating on EVM chains.
+Your wallet address is available via the tools. 
+Always use the tools to interact with the blockchain.
+If the user doesn't specify a chain, default to: ${config.agent.default_chain}.`;
+async function processUserInput(input) {
+    // Add user input to memory
+    logger.addEntry({ role: 'user', content: input });
+    const history = logger.getHistory();
+    // Format messages for OpenAI
+    const messages = [
+        { role: 'system', content: systemPrompt },
+        ...history.map(m => {
+            const msg = { role: m.role, content: m.content || "" };
+            if (m.name)
+                msg.name = m.name;
+            if (m.tool_call_id)
+                msg.tool_call_id = m.tool_call_id;
+            if (m.tool_calls)
+                msg.tool_calls = m.tool_calls;
+            return msg;
+        })
+    ];
+    try {
+        if (config.llm.provider !== 'openai') {
+            return `Provider ${config.llm.provider} is configured, but currently only OpenAI adapter is fully implemented in this demo.`;
+        }
+        const response = await openai.chat.completions.create({
+            model: config.llm.model,
+            temperature: config.llm.temperature,
+            messages: messages,
+            tools: [getBalance_1.getBalanceToolDefinition],
+            tool_choice: "auto",
+        });
+        const responseMessage = response.choices[0].message;
+        // Log assistant response
+        logger.addEntry({
+            role: 'assistant',
+            content: responseMessage.content || "",
+            tool_calls: responseMessage.tool_calls,
+        });
+        // Check if the model wants to call a tool
+        if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
+            for (const toolCall of responseMessage.tool_calls) {
+                if (toolCall.function.name === 'get_balance') {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    const balanceResult = await (0, getBalance_1.getBalance)(args.chainName, args.address);
+                    logger.addEntry({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        name: toolCall.function.name,
+                        content: balanceResult,
+                    });
+                }
+            }
+            // Second call to get the final answer after tool execution
+            const secondMessages = [
+                { role: 'system', content: systemPrompt },
+                ...logger.getHistory().map(m => {
+                    const msg = { role: m.role, content: m.content || "" };
+                    if (m.name)
+                        msg.name = m.name;
+                    if (m.tool_call_id)
+                        msg.tool_call_id = m.tool_call_id;
+                    if (m.tool_calls)
+                        msg.tool_calls = m.tool_calls;
+                    return msg;
+                })
+            ];
+            const secondResponse = await openai.chat.completions.create({
+                model: config.llm.model,
+                messages: secondMessages,
+            });
+            const finalContent = secondResponse.choices[0].message.content || "";
+            logger.addEntry({ role: 'assistant', content: finalContent });
+            return finalContent;
+        }
+        return responseMessage.content || "No response generated.";
+    }
+    catch (error) {
+        console.error("LLM Error:", error);
+        return `Error connecting to AI Provider: ${error.message}`;
+    }
+}

package/dist/src/config/parser.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+const fs_1 = __importDefault(require("fs"));
+const yaml_1 = __importDefault(require("yaml"));
+const path_1 = __importDefault(require("path"));
+function loadConfig() {
+    const configPath = path_1.default.resolve(process.cwd(), 'config.yaml');
+    try {
+        const file = fs_1.default.readFileSync(configPath, 'utf8');
+        const parsed = yaml_1.default.parse(file);
+        return parsed;
+    }
+    catch (error) {
+        console.error('Failed to load config.yaml. Using default configuration.', error);
+        return {
+            agent: { name: 'OpenWeb-Default', default_chain: 'base' },
+            llm: { provider: 'openai', model: 'gpt-4o-mini', temperature: 0.2 },
+            memory: { type: 'file', path: './memory.json' }
+        };
+    }
+}

package/dist/src/gateway/cli.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const reasoning_1 = require("../agent/reasoning");
+const dotenv = __importStar(require("dotenv"));
+const parser_1 = require("../config/parser");
+dotenv.config();
+const rl = readline_1.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+const config = (0, parser_1.loadConfig)();
+console.log(`================================`);
+console.log(`🤖 OpenWeb CLI Agent Started`);
+console.log(`📋 Agent Name: ${config.agent.name}`);
+console.log(`🔗 Default Chain: ${config.agent.default_chain}`);
+console.log(`🧠 AI Provider: ${config.llm.provider} (${config.llm.model})`);
+console.log(`================================`);
+console.log(`Type 'exit' or 'quit' to stop.\n`);
+function ask() {
+    rl.question('👤 You: ', async (input) => {
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+            console.log('Goodbye!');
+            rl.close();
+            return;
+        }
+        if (input.trim() === '') {
+            ask();
+            return;
+        }
+        console.log('🤖 Agent thinking...');
+        try {
+            const response = await (0, reasoning_1.processUserInput)(input);
+            console.log(`\n🤖 OpenWeb: ${response}\n`);
+        }
+        catch (error) {
+            console.log(`\n❌ Error: ${error.message}\n`);
+        }
+        ask();
+    });
+}
+ask();