@ebowwa/glm-daemon 0.3.2 → 0.4.0

package/src/memory.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * Conversation Memory - Generic conversation tracking for any channel
+ *
+ * Tracks chat history per user/conversation with persistence.
+ * Can be used by Telegram, Discord, or any other channel.
+ *
+ * Storage format: JSONL (JSON Lines)
+ * Each line is a JSON object: {"id": "...", "messages": [...], "lastUpdated": timestamp}
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringConversationMemory = exports.NumericConversationMemory = exports.ConversationMemory = void 0;
+var fs_1 = require("fs");
+var path_1 = require("path");
+/**
+ * Generic conversation memory that tracks chat history per conversation ID.
+ *
+ * Uses JSONL format for efficient append-only writes and streaming reads.
+ * Automatically migrates from old JSON format on first load.
+ *
+ * The ID type is generic (string | number) to support different channel types:
+ * - Telegram: number (chatId)
+ * - Discord: string (channelId/userId)
+ * - Slack: string (channelId)
+ *
+ * @example
+ * ```ts
+ * const memory = new ConversationMemory({ maxMessages: 20 });
+ * memory.add(12345, 'user', 'Hello!');
+ * memory.add(12345, 'assistant', 'Hi there!');
+ * const history = memory.get(12345);
+ * ```
+ */
+var ConversationMemory = /** @class */ (function () {
+    function ConversationMemory(config) {
+        if (config === void 0) { config = {}; }
+        var _a, _b;
+        this.conversations = new Map();
+        this.needsFullSave = false;
+        // Default to .jsonl extension
+        var defaultFile = "./conversations.jsonl";
+        this.file = config.file || defaultFile;
+        // Auto-migrate from .json to .jsonl if needed
+        if (config.autoMigrate !== false && !(0, fs_1.existsSync)(this.file)) {
+            this.migrateFromJson(this.file);
+        }
+        this.maxMessages = (_a = config.maxMessages) !== null && _a !== void 0 ? _a : 10;
+        this.includeTimestamps = (_b = config.includeTimestamps) !== null && _b !== void 0 ? _b : true;
+        this.load();
+    }
+    /**
+     * Migrate from old JSON format to JSONL
+     */
+    ConversationMemory.prototype.migrateFromJson = function (jsonlFile) {
+        // Check for old .json file
+        var jsonFile = jsonlFile.replace(/\.jsonl$/, ".json");
+        if (!(0, fs_1.existsSync)(jsonFile))
+            return;
+        try {
+            var data = JSON.parse((0, fs_1.readFileSync)(jsonFile, "utf-8"));
+            var entries = [];
+            for (var _i = 0, _a = Object.entries(data); _i < _a.length; _i++) {
+                var _b = _a[_i], id = _b[0], messages = _b[1];
+                entries.push({
+                    id: id,
+                    messages: messages,
+                    lastUpdated: Date.now(),
+                });
+            }
+            // Write as JSONL
+            var dir = (0, path_1.dirname)(jsonlFile);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            var lines = entries.map(function (e) { return JSON.stringify(e); }).join("\n");
+            (0, fs_1.writeFileSync)(jsonlFile, lines + (lines ? "\n" : ""));
+            // Backup old file instead of deleting
+            var backupFile = jsonFile + ".backup";
+            (0, fs_1.renameSync)(jsonFile, backupFile);
+            console.log("Migrated ".concat(jsonFile, " to ").concat(jsonlFile, " (").concat(entries.length, " conversations)"));
+        }
+        catch (error) {
+            console.error("Migration failed: ".concat(error));
+        }
+    };
+    /**
+     * Load conversations from JSONL file
+     * Uses synchronous read for constructor compatibility
+     */
+    ConversationMemory.prototype.load = function () {
+        if (!(0, fs_1.existsSync)(this.file))
+            return;
+        try {
+            var content = (0, fs_1.readFileSync)(this.file, "utf-8");
+            var lines = content.split("\n");
+            for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+                var line = lines_1[_i];
+                if (!line.trim())
+                    continue;
+                try {
+                    var entry = JSON.parse(line);
+                    var key = this.parseKey(entry.id);
+                    this.conversations.set(key, entry.messages);
+                }
+                catch (_a) {
+                    // Skip malformed lines
+                }
+            }
+        }
+        catch (_b) {
+            // Start fresh on error
+        }
+    };
+    /**
+     * Parse string key back to original type
+     */
+    ConversationMemory.prototype.parseKey = function (id) {
+        // Try to parse as number if it looks like one
+        if (/^-?\d+$/.test(id)) {
+            return Number(id);
+        }
+        return id;
+    };
+    /**
+     * Convert IdType to string for storage
+     */
+    ConversationMemory.prototype.stringifyKey = function (id) {
+        return String(id);
+    };
+    /**
+     * Save all conversations to disk (full rewrite)
+     * Used when entries are deleted or modified
+     */
+    ConversationMemory.prototype.saveFull = function () {
+        try {
+            var dir = (0, path_1.dirname)(this.file);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            var lines = [];
+            for (var _i = 0, _a = this.conversations; _i < _a.length; _i++) {
+                var _b = _a[_i], id = _b[0], messages = _b[1];
+                var entry = {
+                    id: this.stringifyKey(id),
+                    messages: messages,
+                    lastUpdated: Date.now(),
+                };
+                lines.push(JSON.stringify(entry));
+            }
+            (0, fs_1.writeFileSync)(this.file, lines.join("\n") + (lines.length ? "\n" : ""));
+            this.needsFullSave = false;
+        }
+        catch (error) {
+            console.error("Save failed: ".concat(error));
+        }
+    };
+    /**
+     * Append a single entry to the file (efficient for adds)
+     */
+    ConversationMemory.prototype.appendEntry = function (conversationId, messages) {
+        try {
+            var dir = (0, path_1.dirname)(this.file);
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+            var entry = {
+                id: this.stringifyKey(conversationId),
+                messages: messages,
+                lastUpdated: Date.now(),
+            };
+            // Check if file exists and has content to determine if we need newline
+            var hasContent = (0, fs_1.existsSync)(this.file) && (0, fs_1.readFileSync)(this.file, "utf-8").length > 0;
+            var prefix = hasContent ? "" : "";
+            var line = JSON.stringify(entry) + "\n";
+            // We need to do a full save to replace the old entry for this conversation
+            // JSONL doesn't support in-place updates, so we mark for full save
+            this.needsFullSave = true;
+            // For now, do a full save since we need to replace the entry
+            this.saveFull();
+        }
+        catch (error) {
+            console.error("Append failed: ".concat(error));
+        }
+    };
+    /**
+     * Add a message to a conversation
+     */
+    ConversationMemory.prototype.add = function (conversationId, role, content) {
+        if (!this.conversations.has(conversationId)) {
+            this.conversations.set(conversationId, []);
+        }
+        var history = this.conversations.get(conversationId);
+        var message = { role: role, content: content };
+        if (this.includeTimestamps) {
+            message.timestamp = Date.now();
+        }
+        history.push(message);
+        // Keep only last N messages
+        if (history.length > this.maxMessages) {
+            history.splice(0, history.length - this.maxMessages);
+        }
+        // Save the updated conversation
+        this.appendEntry(conversationId, history);
+    };
+    /**
+     * Get conversation history for a specific conversation
+     */
+    ConversationMemory.prototype.get = function (conversationId) {
+        return this.conversations.get(conversationId) || [];
+    };
+    /**
+     * Get all conversations
+     */
+    ConversationMemory.prototype.getAll = function () {
+        return new Map(this.conversations);
+    };
+    /**
+     * Clear a specific conversation
+     */
+    ConversationMemory.prototype.clear = function (conversationId) {
+        this.conversations.delete(conversationId);
+        this.saveFull();
+    };
+    /**
+     * Clear all conversations
+     */
+    ConversationMemory.prototype.clearAll = function () {
+        this.conversations.clear();
+        this.saveFull();
+    };
+    /**
+     * Check if a conversation exists
+     */
+    ConversationMemory.prototype.has = function (conversationId) {
+        return this.conversations.has(conversationId);
+    };
+    /**
+     * Get the number of conversations
+     */
+    ConversationMemory.prototype.size = function () {
+        return this.conversations.size;
+    };
+    /**
+     * Get the messages count for a specific conversation
+     */
+    ConversationMemory.prototype.messageCount = function (conversationId) {
+        var _a;
+        return ((_a = this.conversations.get(conversationId)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    };
+    /**
+     * Get formatted history for API calls (OpenAI/Anthropic format)
+     */
+    ConversationMemory.prototype.getForAPI = function (conversationId) {
+        return this.get(conversationId).map(function (_a) {
+            var role = _a.role, content = _a.content;
+            return ({
+                role: role,
+                content: content,
+            });
+        });
+    };
+    /**
+     * Force a full save (useful before shutdown)
+     */
+    ConversationMemory.prototype.flush = function () {
+        if (this.needsFullSave || this.conversations.size > 0) {
+            this.saveFull();
+        }
+    };
+    /**
+     * Get the file path being used
+     */
+    ConversationMemory.prototype.getFilePath = function () {
+        return this.file;
+    };
+    /**
+     * Check if the storage uses JSONL format
+     */
+    ConversationMemory.prototype.isJsonl = function () {
+        return this.file.endsWith(".jsonl");
+    };
+    return ConversationMemory;
+}());
+exports.ConversationMemory = ConversationMemory;
+/**
+ * Pre-configured memory for numeric IDs (like Telegram chat IDs)
+ */
+var NumericConversationMemory = /** @class */ (function (_super) {
+    __extends(NumericConversationMemory, _super);
+    function NumericConversationMemory(config) {
+        if (config === void 0) { config = {}; }
+        return _super.call(this, config) || this;
+    }
+    return NumericConversationMemory;
+}(ConversationMemory));
+exports.NumericConversationMemory = NumericConversationMemory;
+/**
+ * Pre-configured memory for string IDs (like Discord/Slack channel IDs)
+ */
+var StringConversationMemory = /** @class */ (function (_super) {
+    __extends(StringConversationMemory, _super);
+    function StringConversationMemory(config) {
+        if (config === void 0) { config = {}; }
+        return _super.call(this, config) || this;
+    }
+    return StringConversationMemory;
+}(ConversationMemory));
+exports.StringConversationMemory = StringConversationMemory;

package/src/state.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * GLM Daemon - State Manager
+ *
+ * Manages SLAM state persistence to disk.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+var fs_1 = require("fs");
+var StateManager = /** @class */ (function () {
+    function StateManager(statePath) {
+        this.statePath = statePath;
+    }
+    /**
+     * Load state from disk
+     */
+    StateManager.prototype.load = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var content, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs_1.promises.readFile(this.statePath, "utf-8")];
+                    case 1:
+                        content = _b.sent();
+                        return [2 /*return*/, JSON.parse(content)];
+                    case 2:
+                        _a = _b.sent();
+                        // File doesn't exist or invalid JSON
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Save state to disk
+     */
+    StateManager.prototype.save = function (state) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fs_1.promises.writeFile(this.statePath, JSON.stringify(state, null, 2), "utf-8")];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Delete state file
+     */
+    StateManager.prototype.delete = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs_1.promises.unlink(this.statePath)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check if state file exists
+     */
+    StateManager.prototype.exists = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, fs_1.promises.access(this.statePath)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/, true];
+                    case 2:
+                        _a = _b.sent();
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Update a portion of state (merge)
+     */
+    StateManager.prototype.update = function (updates) {
+        return __awaiter(this, void 0, void 0, function () {
+            var current, updated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.load()];
+                    case 1:
+                        current = _a.sent();
+                        if (!current) {
+                            throw new Error("No existing state to update");
+                        }
+                        updated = __assign(__assign({}, current), updates);
+                        return [4 /*yield*/, this.save(updated)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, updated];
+                }
+            });
+        });
+    };
+    return StateManager;
+}());
+exports.StateManager = StateManager;

package/src/tools.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * GLM Daemon - Tool Bridge
+ *
+ * Connects GLM agents to MCP servers for tool access.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolBridge = void 0;
+var ToolBridge = /** @class */ (function () {
+    function ToolBridge(config) {
+        if (config === void 0) { config = {}; }
+        this.availableTools = [];
+        this.config = config;
+        this.toolTimeout = config.toolTimeout || 30000;
+        this.maxRetries = config.maxRetries || 3;
+    }
+    /**
+     * Get list of available tools
+     */
+    ToolBridge.prototype.getAvailableTools = function () {
+        return this.availableTools;
+    };
+    /**
+     * Set available tools (from MCP discovery)
+     */
+    ToolBridge.prototype.setAvailableTools = function (tools) {
+        this.availableTools = tools;
+    };
+    /**
+     * Check if a tool is allowed
+     */
+    ToolBridge.prototype.isToolAllowed = function (toolName) {
+        var _a;
+        // Check blacklist first
+        if ((_a = this.config.blockedTools) === null || _a === void 0 ? void 0 : _a.includes(toolName)) {
+            return false;
+        }
+        // If whitelist exists, check it
+        if (this.config.allowedTools && this.config.allowedTools.length > 0) {
+            return this.config.allowedTools.includes(toolName);
+        }
+        // Default: allow if not blocked
+        return true;
+    };
+    /**
+     * Execute a tool with timeout and retry
+     */
+    ToolBridge.prototype.executeTool = function (toolName, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lastError, _loop_1, this_1, attempt, state_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.isToolAllowed(toolName)) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: "Tool not allowed: ".concat(toolName),
+                                }];
+                        }
+                        lastError = null;
+                        _loop_1 = function (attempt) {
+                            var result, error_1;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _b.trys.push([0, 2, , 5]);
+                                        return [4 /*yield*/, this_1.executeWithTimeout(toolName, args)];
+                                    case 1:
+                                        result = _b.sent();
+                                        return [2 /*return*/, { value: { success: true, result: result } }];
+                                    case 2:
+                                        error_1 = _b.sent();
+                                        lastError = error_1;
+                                        if (!(attempt < this_1.maxRetries - 1)) return [3 /*break*/, 4];
+                                        return [4 /*yield*/, new Promise(function (resolve) {
+                                                return setTimeout(resolve, Math.pow(2, attempt) * 1000);
+                                            })];
+                                    case 3:
+                                        _b.sent();
+                                        _b.label = 4;
+                                    case 4: return [3 /*break*/, 5];
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        attempt = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(attempt < this.maxRetries)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1(attempt)];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        _a.label = 3;
+                    case 3:
+                        attempt++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, {
+                            success: false,
+                            error: (lastError === null || lastError === void 0 ? void 0 : lastError.message) || "Unknown error",
+                        }];
+                }
+            });
+        });
+    };
+    /**
+     * Execute tool with timeout
+     */
+    ToolBridge.prototype.executeWithTimeout = function (toolName, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var timer = setTimeout(function () {
+                            reject(new Error("Tool timeout: ".concat(toolName)));
+                        }, _this.toolTimeout);
+                        // TODO: Actually call MCP tool here
+                        // For now, this is a placeholder
+                        setTimeout(function () {
+                            clearTimeout(timer);
+                            resolve("Executed ".concat(toolName, " with ").concat(JSON.stringify(args)));
+                        }, 100);
+                    })];
+            });
+        });
+    };
+    /**
+     * Discover tools from MCP servers
+     */
+    ToolBridge.prototype.discoverMCPTools = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var commonTools;
+            return __generator(this, function (_a) {
+                if (!this.config.enableMCP) {
+                    return [2 /*return*/];
+                }
+                commonTools = [
+                    "Read",
+                    "Write",
+                    "Edit",
+                    "Grep",
+                    "Glob",
+                    "Bash",
+                    "git_status",
+                    "git_commit",
+                ];
+                this.setAvailableTools(commonTools);
+                return [2 /*return*/];
+            });
+        });
+    };
+    return ToolBridge;
+}());
+exports.ToolBridge = ToolBridge;