kynjal-cli 4.0.0 → 4.0.1

package/dist/src/mcp-tools/agentdb-tools.js

@@ -10,48 +10,11 @@
  *
  * @module v3/cli/mcp-tools/agentdb-tools
  */
-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;
-    return g = { next: verb(0), "throw": verb(1), "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 (_) 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 };
-    }
-};
 // ===== Shared validation helpers =====
-var MAX_STRING_LENGTH = 100000; // 100KB max for any string input
-var MAX_BATCH_SIZE = 500; // Max entries per batch operation
-var MAX_TOP_K = 100; // Max results per query
-function validateString(value, name, maxLen) {
-    if (maxLen === void 0) { maxLen = MAX_STRING_LENGTH; }
+const MAX_STRING_LENGTH = 100_000; // 100KB max for any string input
+const MAX_BATCH_SIZE = 500; // Max entries per batch operation
+const MAX_TOP_K = 100; // Max results per query
+function validateString(value, name, maxLen = MAX_STRING_LENGTH) {
     if (typeof value !== 'string' || value.length === 0)
         return null;
     if (value.length > maxLen)
@@ -61,7 +24,7 @@ function validateString(value, name, maxLen) {
 function validatePositiveInt(value, defaultVal, max) {
     if (typeof value !== 'number' || !Number.isFinite(value))
         return defaultVal;
-    var n = Math.floor(value);
+    const n = Math.floor(value);
     return n > 0 ? Math.min(n, max) : defaultVal;
 }
 function validateScore(value, defaultVal) {
@@ -77,91 +40,62 @@ function sanitizeError(error) {
     return 'Internal error';
 }
 // Lazy-cached bridge module
-var bridgeModule = null;
-function getBridge() {
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!!bridgeModule) return [3 /*break*/, 2];
-                    return [4 /*yield*/, import('../memory/memory-bridge.js')];
-                case 1:
-                    bridgeModule = _a.sent();
-                    _a.label = 2;
-                case 2: return [2 /*return*/, bridgeModule];
-            }
-        });
-    });
+let bridgeModule = null;
+async function getBridge() {
+    if (!bridgeModule) {
+        bridgeModule = await import('../memory/memory-bridge.js');
+    }
+    return bridgeModule;
 }
 // ===== agentdb_health — Controller health check =====
-export var agentdbHealth = {
+export const agentdbHealth = {
     name: 'agentdb_health',
     description: 'Get AgentDB v3 controller health status including cache stats and attestation count',
     inputSchema: {
         type: 'object',
-        properties: {}
+        properties: {},
+    },
+    handler: async () => {
+        try {
+            const bridge = await getBridge();
+            const health = await bridge.bridgeHealthCheck();
+            if (!health)
+                return { available: false, error: 'AgentDB bridge not available' };
+            return health;
+        }
+        catch (error) {
+            return { available: false, error: sanitizeError(error) };
+        }
     },
-    handler: function () { return __awaiter(void 0, void 0, void 0, function () {
-        var bridge, health, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeHealthCheck()];
-                case 2:
-                    health = _a.sent();
-                    if (!health)
-                        return [2 /*return*/, { available: false, error: 'AgentDB bridge not available' }];
-                    return [2 /*return*/, health];
-                case 3:
-                    error_1 = _a.sent();
-                    return [2 /*return*/, { available: false, error: sanitizeError(error_1) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_controllers — List all controllers =====
-export var agentdbControllers = {
+export const agentdbControllers = {
     name: 'agentdb_controllers',
     description: 'List all AgentDB v3 controllers and their initialization status',
     inputSchema: {
         type: 'object',
-        properties: {}
+        properties: {},
+    },
+    handler: async () => {
+        try {
+            const bridge = await getBridge();
+            const controllers = await bridge.bridgeListControllers();
+            if (!controllers)
+                return { available: false, controllers: [], error: 'AgentDB bridge not available — @claude-flow/memory not installed or missing controller-registry. Use memory_store/memory_search tools instead.' };
+            return {
+                available: true,
+                controllers,
+                total: controllers.length,
+                active: controllers.filter((c) => c.enabled).length,
+            };
+        }
+        catch (error) {
+            return { available: false, error: sanitizeError(error) };
+        }
     },
-    handler: function () { return __awaiter(void 0, void 0, void 0, function () {
-        var bridge, controllers, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeListControllers()];
-                case 2:
-                    controllers = _a.sent();
-                    if (!controllers)
-                        return [2 /*return*/, { available: false, controllers: [], error: 'AgentDB bridge not available — @claude-flow/memory not installed or missing controller-registry. Use memory_store/memory_search tools instead.' }];
-                    return [2 /*return*/, {
-                            available: true,
-                            controllers: controllers,
-                            total: controllers.length,
-                            active: controllers.filter(function (c) { return c.enabled; }).length
-                        }];
-                case 3:
-                    error_2 = _a.sent();
-                    return [2 /*return*/, { available: false, error: sanitizeError(error_2) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_pattern_store — Store via ReasoningBank =====
-export var agentdbPatternStore = {
+export const agentdbPatternStore = {
     name: 'agentdb_pattern-store',
     description: 'Store a pattern directly via ReasoningBank controller',
     inputSchema: {
@@ -169,41 +103,30 @@ export var agentdbPatternStore = {
         properties: {
             pattern: { type: 'string', description: 'Pattern description' },
             type: { type: 'string', description: 'Pattern type (e.g., task-routing, error-recovery)' },
-            confidence: { type: 'number', description: 'Confidence score (0-1)' }
+            confidence: { type: 'number', description: 'Confidence score (0-1)' },
         },
-        required: ['pattern']
+        required: ['pattern'],
+    },
+    handler: async (params) => {
+        try {
+            const pattern = validateString(params.pattern, 'pattern');
+            if (!pattern)
+                return { success: false, error: 'pattern is required (non-empty string, max 100KB)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeStorePattern({
+                pattern,
+                type: validateString(params.type, 'type', 200) ?? 'general',
+                confidence: validateScore(params.confidence, 0.8),
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var pattern, bridge, result, error_3;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 3, , 4]);
-                    pattern = validateString(params.pattern, 'pattern');
-                    if (!pattern)
-                        return [2 /*return*/, { success: false, error: 'pattern is required (non-empty string, max 100KB)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    return [4 /*yield*/, bridge.bridgeStorePattern({
-                            pattern: pattern,
-                            type: (_a = validateString(params.type, 'type', 200)) !== null && _a !== void 0 ? _a : 'general',
-                            confidence: validateScore(params.confidence, 0.8)
-                        })];
-                case 2:
-                    result = _b.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_3 = _b.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_3) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_pattern_search — Search via ReasoningBank =====
-export var agentdbPatternSearch = {
+export const agentdbPatternSearch = {
     name: 'agentdb_pattern-search',
     description: 'Search patterns via ReasoningBank controller with BM25+semantic hybrid',
     inputSchema: {
@@ -211,40 +134,30 @@ export var agentdbPatternSearch = {
         properties: {
             query: { type: 'string', description: 'Search query' },
             topK: { type: 'number', description: 'Number of results (default: 5)' },
-            minConfidence: { type: 'number', description: 'Minimum score threshold (0-1)' }
+            minConfidence: { type: 'number', description: 'Minimum score threshold (0-1)' },
         },
-        required: ['query']
+        required: ['query'],
+    },
+    handler: async (params) => {
+        try {
+            const query = validateString(params.query, 'query', 10_000);
+            if (!query)
+                return { results: [], error: 'query is required (non-empty string, max 10KB)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeSearchPatterns({
+                query,
+                topK: validatePositiveInt(params.topK, 5, MAX_TOP_K),
+                minConfidence: validateScore(params.minConfidence, 0.3),
+            });
+            return result ?? { results: [], controller: 'unavailable' };
+        }
+        catch (error) {
+            return { results: [], error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var query, bridge, result, error_4;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    query = validateString(params.query, 'query', 10000);
-                    if (!query)
-                        return [2 /*return*/, { results: [], error: 'query is required (non-empty string, max 10KB)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeSearchPatterns({
-                            query: query,
-                            topK: validatePositiveInt(params.topK, 5, MAX_TOP_K),
-                            minConfidence: validateScore(params.minConfidence, 0.3)
-                        })];
-                case 2:
-                    result = _a.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { results: [], controller: 'unavailable' }];
-                case 3:
-                    error_4 = _a.sent();
-                    return [2 /*return*/, { results: [], error: sanitizeError(error_4) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_feedback — Record task feedback =====
-export var agentdbFeedback = {
+export const agentdbFeedback = {
     name: 'agentdb_feedback',
     description: 'Record task feedback for learning via LearningSystem + ReasoningBank controllers',
     inputSchema: {
@@ -253,42 +166,31 @@ export var agentdbFeedback = {
             taskId: { type: 'string', description: 'Task identifier' },
             success: { type: 'boolean', description: 'Whether task succeeded' },
             quality: { type: 'number', description: 'Quality score (0-1)' },
-            agent: { type: 'string', description: 'Agent that performed the task' }
+            agent: { type: 'string', description: 'Agent that performed the task' },
         },
-        required: ['taskId']
+        required: ['taskId'],
+    },
+    handler: async (params) => {
+        try {
+            const taskId = validateString(params.taskId, 'taskId', 500);
+            if (!taskId)
+                return { success: false, error: 'taskId is required (non-empty string, max 500 chars)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeRecordFeedback({
+                taskId,
+                success: params.success === true,
+                quality: validateScore(params.quality, 0.85),
+                agent: validateString(params.agent, 'agent', 200) ?? undefined,
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var taskId, bridge, result, error_5;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 3, , 4]);
-                    taskId = validateString(params.taskId, 'taskId', 500);
-                    if (!taskId)
-                        return [2 /*return*/, { success: false, error: 'taskId is required (non-empty string, max 500 chars)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    return [4 /*yield*/, bridge.bridgeRecordFeedback({
-                            taskId: taskId,
-                            success: params.success === true,
-                            quality: validateScore(params.quality, 0.85),
-                            agent: (_a = validateString(params.agent, 'agent', 200)) !== null && _a !== void 0 ? _a : undefined
-                        })];
-                case 2:
-                    result = _b.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_5 = _b.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_5) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_causal_edge — Record causal relationships =====
-export var agentdbCausalEdge = {
+export const agentdbCausalEdge = {
     name: 'agentdb_causal-edge',
     description: 'Record a causal edge between two memory entries via CausalMemoryGraph',
     inputSchema: {
@@ -297,127 +199,95 @@ export var agentdbCausalEdge = {
             sourceId: { type: 'string', description: 'Source entry ID' },
             targetId: { type: 'string', description: 'Target entry ID' },
             relation: { type: 'string', description: 'Relationship type (e.g., caused, preceded, succeeded)' },
-            weight: { type: 'number', description: 'Edge weight (0-1)' }
+            weight: { type: 'number', description: 'Edge weight (0-1)' },
         },
-        required: ['sourceId', 'targetId', 'relation']
+        required: ['sourceId', 'targetId', 'relation'],
+    },
+    handler: async (params) => {
+        try {
+            const sourceId = validateString(params.sourceId, 'sourceId', 500);
+            const targetId = validateString(params.targetId, 'targetId', 500);
+            const relation = validateString(params.relation, 'relation', 200);
+            if (!sourceId)
+                return { success: false, error: 'sourceId is required (non-empty string)' };
+            if (!targetId)
+                return { success: false, error: 'targetId is required (non-empty string)' };
+            if (!relation)
+                return { success: false, error: 'relation is required (non-empty string)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeRecordCausalEdge({
+                sourceId,
+                targetId,
+                relation,
+                weight: typeof params.weight === 'number' ? validateScore(params.weight, 0.5) : undefined,
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var sourceId, targetId, relation, bridge, result, error_6;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    sourceId = validateString(params.sourceId, 'sourceId', 500);
-                    targetId = validateString(params.targetId, 'targetId', 500);
-                    relation = validateString(params.relation, 'relation', 200);
-                    if (!sourceId)
-                        return [2 /*return*/, { success: false, error: 'sourceId is required (non-empty string)' }];
-                    if (!targetId)
-                        return [2 /*return*/, { success: false, error: 'targetId is required (non-empty string)' }];
-                    if (!relation)
-                        return [2 /*return*/, { success: false, error: 'relation is required (non-empty string)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeRecordCausalEdge({
-                            sourceId: sourceId,
-                            targetId: targetId,
-                            relation: relation,
-                            weight: typeof params.weight === 'number' ? validateScore(params.weight, 0.5) : undefined
-                        })];
-                case 2:
-                    result = _a.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_6 = _a.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_6) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_route — Route via SemanticRouter =====
-export var agentdbRoute = {
+export const agentdbRoute = {
     name: 'agentdb_route',
     description: 'Route a task via AgentDB SemanticRouter or LearningSystem recommendAlgorithm',
     inputSchema: {
         type: 'object',
         properties: {
             task: { type: 'string', description: 'Task description to route' },
-            context: { type: 'string', description: 'Additional context' }
+            context: { type: 'string', description: 'Additional context' },
         },
-        required: ['task']
+        required: ['task'],
+    },
+    handler: async (params) => {
+        try {
+            const task = validateString(params.task, 'task', 10_000);
+            if (!task)
+                return { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'error', error: 'task is required (non-empty string)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeRouteTask({
+                task,
+                context: validateString(params.context, 'context', 10_000) ?? undefined,
+            });
+            return result ?? { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'fallback' };
+        }
+        catch (error) {
+            return { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'error', error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var task, bridge, result, error_7;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 3, , 4]);
-                    task = validateString(params.task, 'task', 10000);
-                    if (!task)
-                        return [2 /*return*/, { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'error', error: 'task is required (non-empty string)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    return [4 /*yield*/, bridge.bridgeRouteTask({
-                            task: task,
-                            context: (_a = validateString(params.context, 'context', 10000)) !== null && _a !== void 0 ? _a : undefined
-                        })];
-                case 2:
-                    result = _b.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'fallback' }];
-                case 3:
-                    error_7 = _b.sent();
-                    return [2 /*return*/, { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'error', error: sanitizeError(error_7) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_session_start — Session with ReflexionMemory =====
-export var agentdbSessionStart = {
+export const agentdbSessionStart = {
     name: 'agentdb_session-start',
     description: 'Start a session with ReflexionMemory episodic replay',
     inputSchema: {
         type: 'object',
         properties: {
             sessionId: { type: 'string', description: 'Session identifier' },
-            context: { type: 'string', description: 'Session context for pattern retrieval' }
+            context: { type: 'string', description: 'Session context for pattern retrieval' },
         },
-        required: ['sessionId']
+        required: ['sessionId'],
+    },
+    handler: async (params) => {
+        try {
+            const sessionId = validateString(params.sessionId, 'sessionId', 500);
+            if (!sessionId)
+                return { success: false, error: 'sessionId is required (non-empty string)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeSessionStart({
+                sessionId,
+                context: validateString(params.context, 'context', 10_000) ?? undefined,
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var sessionId, bridge, result, error_8;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 3, , 4]);
-                    sessionId = validateString(params.sessionId, 'sessionId', 500);
-                    if (!sessionId)
-                        return [2 /*return*/, { success: false, error: 'sessionId is required (non-empty string)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    return [4 /*yield*/, bridge.bridgeSessionStart({
-                            sessionId: sessionId,
-                            context: (_a = validateString(params.context, 'context', 10000)) !== null && _a !== void 0 ? _a : undefined
-                        })];
-                case 2:
-                    result = _b.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_8 = _b.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_8) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_session_end — End session + NightlyLearner =====
-export var agentdbSessionEnd = {
+export const agentdbSessionEnd = {
     name: 'agentdb_session-end',
     description: 'End session, persist to ReflexionMemory, trigger NightlyLearner consolidation',
     inputSchema: {
@@ -425,41 +295,30 @@ export var agentdbSessionEnd = {
         properties: {
             sessionId: { type: 'string', description: 'Session identifier' },
             summary: { type: 'string', description: 'Session summary' },
-            tasksCompleted: { type: 'number', description: 'Number of tasks completed' }
+            tasksCompleted: { type: 'number', description: 'Number of tasks completed' },
         },
-        required: ['sessionId']
+        required: ['sessionId'],
+    },
+    handler: async (params) => {
+        try {
+            const sessionId = validateString(params.sessionId, 'sessionId', 500);
+            if (!sessionId)
+                return { success: false, error: 'sessionId is required (non-empty string)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeSessionEnd({
+                sessionId,
+                summary: validateString(params.summary, 'summary', 50_000) ?? undefined,
+                tasksCompleted: validatePositiveInt(params.tasksCompleted, 0, 10_000),
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var sessionId, bridge, result, error_9;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 3, , 4]);
-                    sessionId = validateString(params.sessionId, 'sessionId', 500);
-                    if (!sessionId)
-                        return [2 /*return*/, { success: false, error: 'sessionId is required (non-empty string)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    return [4 /*yield*/, bridge.bridgeSessionEnd({
-                            sessionId: sessionId,
-                            summary: (_a = validateString(params.summary, 'summary', 50000)) !== null && _a !== void 0 ? _a : undefined,
-                            tasksCompleted: validatePositiveInt(params.tasksCompleted, 0, 10000)
-                        })];
-                case 2:
-                    result = _b.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_9 = _b.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_9) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_hierarchical_store — Store to hierarchical memory =====
-export var agentdbHierarchicalStore = {
+export const agentdbHierarchicalStore = {
     name: 'agentdb_hierarchical-store',
     description: 'Store to hierarchical memory with tier (working, episodic, semantic)',
     inputSchema: {
@@ -470,46 +329,35 @@ export var agentdbHierarchicalStore = {
             tier: {
                 type: 'string',
                 description: 'Memory tier (working, episodic, semantic)',
-                "enum": ['working', 'episodic', 'semantic'],
-                "default": 'working'
-            }
+                enum: ['working', 'episodic', 'semantic'],
+                default: 'working',
+            },
         },
-        required: ['key', 'value']
+        required: ['key', 'value'],
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var key, value, tier, bridge, result, error_10;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 3, , 4]);
-                    key = validateString(params.key, 'key', 1000);
-                    value = validateString(params.value, 'value');
-                    if (!key)
-                        return [2 /*return*/, { success: false, error: 'key is required (non-empty string, max 1KB)' }];
-                    if (!value)
-                        return [2 /*return*/, { success: false, error: 'value is required (non-empty string, max 100KB)' }];
-                    tier = (_a = validateString(params.tier, 'tier', 20)) !== null && _a !== void 0 ? _a : 'working';
-                    if (!['working', 'episodic', 'semantic'].includes(tier)) {
-                        return [2 /*return*/, { success: false, error: "Invalid tier: " + tier + ". Must be working, episodic, or semantic" }];
-                    }
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _b.sent();
-                    return [4 /*yield*/, bridge.bridgeHierarchicalStore({ key: key, value: value, tier: tier })];
-                case 2:
-                    result = _b.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_10 = _b.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_10) }];
-                case 4: return [2 /*return*/];
+    handler: async (params) => {
+        try {
+            const key = validateString(params.key, 'key', 1000);
+            const value = validateString(params.value, 'value');
+            if (!key)
+                return { success: false, error: 'key is required (non-empty string, max 1KB)' };
+            if (!value)
+                return { success: false, error: 'value is required (non-empty string, max 100KB)' };
+            const tier = validateString(params.tier, 'tier', 20) ?? 'working';
+            if (!['working', 'episodic', 'semantic'].includes(tier)) {
+                return { success: false, error: `Invalid tier: ${tier}. Must be working, episodic, or semantic` };
             }
-        });
-    }); }
+            const bridge = await getBridge();
+            const result = await bridge.bridgeHierarchicalStore({ key, value, tier });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
+    },
 };
 // ===== agentdb_hierarchical_recall — Recall from hierarchical memory =====
-export var agentdbHierarchicalRecall = {
+export const agentdbHierarchicalRecall = {
     name: 'agentdb_hierarchical-recall',
     description: 'Recall from hierarchical memory with optional tier filter',
     inputSchema: {
@@ -517,79 +365,59 @@ export var agentdbHierarchicalRecall = {
         properties: {
             query: { type: 'string', description: 'Recall query' },
             tier: { type: 'string', description: 'Filter by tier (working, episodic, semantic)' },
-            topK: { type: 'number', description: 'Number of results (default: 5)' }
+            topK: { type: 'number', description: 'Number of results (default: 5)' },
         },
-        required: ['query']
+        required: ['query'],
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var query, tier, bridge, result, error_11;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    query = validateString(params.query, 'query', 10000);
-                    if (!query)
-                        return [2 /*return*/, { results: [], error: 'query is required (non-empty string, max 10KB)' }];
-                    tier = validateString(params.tier, 'tier', 20);
-                    if (tier && !['working', 'episodic', 'semantic'].includes(tier)) {
-                        return [2 /*return*/, { results: [], error: "Invalid tier: " + tier + ". Must be working, episodic, or semantic" }];
-                    }
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeHierarchicalRecall({
-                            query: query,
-                            tier: tier !== null && tier !== void 0 ? tier : undefined,
-                            topK: validatePositiveInt(params.topK, 5, MAX_TOP_K)
-                        })];
-                case 2:
-                    result = _a.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { results: [], error: 'AgentDB bridge not available. Use memory_search instead.' }];
-                case 3:
-                    error_11 = _a.sent();
-                    return [2 /*return*/, { results: [], error: sanitizeError(error_11) }];
-                case 4: return [2 /*return*/];
+    handler: async (params) => {
+        try {
+            const query = validateString(params.query, 'query', 10_000);
+            if (!query)
+                return { results: [], error: 'query is required (non-empty string, max 10KB)' };
+            const tier = validateString(params.tier, 'tier', 20);
+            if (tier && !['working', 'episodic', 'semantic'].includes(tier)) {
+                return { results: [], error: `Invalid tier: ${tier}. Must be working, episodic, or semantic` };
             }
-        });
-    }); }
+            const bridge = await getBridge();
+            const result = await bridge.bridgeHierarchicalRecall({
+                query,
+                tier: tier ?? undefined,
+                topK: validatePositiveInt(params.topK, 5, MAX_TOP_K),
+            });
+            return result ?? { results: [], error: 'AgentDB bridge not available. Use memory_search instead.' };
+        }
+        catch (error) {
+            return { results: [], error: sanitizeError(error) };
+        }
+    },
 };
 // ===== agentdb_consolidate — Run memory consolidation =====
-export var agentdbConsolidate = {
+export const agentdbConsolidate = {
     name: 'agentdb_consolidate',
     description: 'Run memory consolidation to promote entries across tiers and compress old data',
     inputSchema: {
         type: 'object',
         properties: {
             minAge: { type: 'number', description: 'Minimum age in hours since store (optional)' },
-            maxEntries: { type: 'number', description: 'Maximum entries to consolidate (optional)' }
+            maxEntries: { type: 'number', description: 'Maximum entries to consolidate (optional)' },
+        },
+    },
+    handler: async (params) => {
+        try {
+            const bridge = await getBridge();
+            const result = await bridge.bridgeConsolidate({
+                minAge: typeof params.minAge === 'number' ? Math.max(0, params.minAge) : undefined,
+                maxEntries: validatePositiveInt(params.maxEntries, 1000, 10_000),
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
         }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var bridge, result, error_12;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeConsolidate({
-                            minAge: typeof params.minAge === 'number' ? Math.max(0, params.minAge) : undefined,
-                            maxEntries: validatePositiveInt(params.maxEntries, 1000, 10000)
-                        })];
-                case 2:
-                    result = _a.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_12 = _a.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_12) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_batch — Batch operations (insert, update, delete) =====
-export var agentdbBatch = {
+export const agentdbBatch = {
     name: 'agentdb_batch',
     description: 'Batch operations on memory entries (insert, update, delete)',
     inputSchema: {
@@ -598,7 +426,7 @@ export var agentdbBatch = {
             operation: {
                 type: 'string',
                 description: 'Batch operation type',
-                "enum": ['insert', 'update', 'delete']
+                enum: ['insert', 'update', 'delete'],
             },
             entries: {
                 type: 'array',
@@ -607,138 +435,109 @@ export var agentdbBatch = {
                     type: 'object',
                     properties: {
                         key: { type: 'string' },
-                        value: { type: 'string' }
+                        value: { type: 'string' },
                     },
-                    required: ['key']
-                }
-            }
+                    required: ['key'],
+                },
+            },
         },
-        required: ['operation', 'entries']
+        required: ['operation', 'entries'],
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var operation, validatedEntries, i, entry, key, value, bridge, result, error_13;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    operation = validateString(params.operation, 'operation', 20);
-                    if (!operation)
-                        return [2 /*return*/, { success: false, error: 'operation is required (string)' }];
-                    if (!['insert', 'update', 'delete'].includes(operation)) {
-                        return [2 /*return*/, { success: false, error: "Invalid operation: " + operation + ". Must be insert, update, or delete" }];
-                    }
-                    if (!Array.isArray(params.entries) || params.entries.length === 0) {
-                        return [2 /*return*/, { success: false, error: 'entries is required (non-empty array)' }];
-                    }
-                    if (params.entries.length > MAX_BATCH_SIZE) {
-                        return [2 /*return*/, { success: false, error: "Too many entries: " + params.entries.length + ". Max is " + MAX_BATCH_SIZE }];
-                    }
-                    validatedEntries = [];
-                    for (i = 0; i < params.entries.length; i++) {
-                        entry = params.entries[i];
-                        if (!entry || typeof entry !== 'object') {
-                            return [2 /*return*/, { success: false, error: "entries[" + i + "] must be an object" }];
-                        }
-                        key = validateString(entry.key, "entries[" + i + "].key", 1000);
-                        if (!key)
-                            return [2 /*return*/, { success: false, error: "entries[" + i + "].key is required (non-empty string)" }];
-                        value = validateString(entry.value, "entries[" + i + "].value");
-                        validatedEntries.push({ key: key, value: value !== null && value !== void 0 ? value : undefined });
-                    }
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeBatchOperation({
-                            operation: operation,
-                            entries: validatedEntries
-                        })];
-                case 2:
-                    result = _a.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_13 = _a.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_13) }];
-                case 4: return [2 /*return*/];
+    handler: async (params) => {
+        try {
+            const operation = validateString(params.operation, 'operation', 20);
+            if (!operation)
+                return { success: false, error: 'operation is required (string)' };
+            if (!['insert', 'update', 'delete'].includes(operation)) {
+                return { success: false, error: `Invalid operation: ${operation}. Must be insert, update, or delete` };
+            }
+            if (!Array.isArray(params.entries) || params.entries.length === 0) {
+                return { success: false, error: 'entries is required (non-empty array)' };
+            }
+            if (params.entries.length > MAX_BATCH_SIZE) {
+                return { success: false, error: `Too many entries: ${params.entries.length}. Max is ${MAX_BATCH_SIZE}` };
             }
-        });
-    }); }
+            // Validate each entry
+            const validatedEntries = [];
+            for (let i = 0; i < params.entries.length; i++) {
+                const entry = params.entries[i];
+                if (!entry || typeof entry !== 'object') {
+                    return { success: false, error: `entries[${i}] must be an object` };
+                }
+                const key = validateString(entry.key, `entries[${i}].key`, 1000);
+                if (!key)
+                    return { success: false, error: `entries[${i}].key is required (non-empty string)` };
+                const value = validateString(entry.value, `entries[${i}].value`);
+                validatedEntries.push({ key, value: value ?? undefined });
+            }
+            const bridge = await getBridge();
+            const result = await bridge.bridgeBatchOperation({
+                operation,
+                entries: validatedEntries,
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
+    },
 };
 // ===== agentdb_context_synthesize — Synthesize context from memories =====
-export var agentdbContextSynthesize = {
+export const agentdbContextSynthesize = {
     name: 'agentdb_context-synthesize',
     description: 'Synthesize context from stored memories for a given query',
     inputSchema: {
         type: 'object',
         properties: {
             query: { type: 'string', description: 'Query to synthesize context for' },
-            maxEntries: { type: 'number', description: 'Maximum entries to include (default: 10)' }
+            maxEntries: { type: 'number', description: 'Maximum entries to include (default: 10)' },
         },
-        required: ['query']
+        required: ['query'],
+    },
+    handler: async (params) => {
+        try {
+            const query = validateString(params.query, 'query', 10_000);
+            if (!query)
+                return { success: false, error: 'query is required (non-empty string, max 10KB)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeContextSynthesize({
+                query,
+                maxEntries: validatePositiveInt(params.maxEntries, 10, MAX_TOP_K),
+            });
+            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+        }
+        catch (error) {
+            return { success: false, error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var query, bridge, result, error_14;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    query = validateString(params.query, 'query', 10000);
-                    if (!query)
-                        return [2 /*return*/, { success: false, error: 'query is required (non-empty string, max 10KB)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeContextSynthesize({
-                            query: query,
-                            maxEntries: validatePositiveInt(params.maxEntries, 10, MAX_TOP_K)
-                        })];
-                case 2:
-                    result = _a.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' }];
-                case 3:
-                    error_14 = _a.sent();
-                    return [2 /*return*/, { success: false, error: sanitizeError(error_14) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== agentdb_semantic_route — Route via SemanticRouter =====
-export var agentdbSemanticRoute = {
+export const agentdbSemanticRoute = {
     name: 'agentdb_semantic-route',
     description: 'Route an input via AgentDB SemanticRouter for intent classification',
     inputSchema: {
         type: 'object',
         properties: {
-            input: { type: 'string', description: 'Input text to route' }
+            input: { type: 'string', description: 'Input text to route' },
         },
-        required: ['input']
+        required: ['input'],
+    },
+    handler: async (params) => {
+        try {
+            const input = validateString(params.input, 'input', 10_000);
+            if (!input)
+                return { route: null, error: 'input is required (non-empty string, max 10KB)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeSemanticRoute({ input });
+            return result ?? { route: null, error: 'AgentDB bridge not available. Use hooks route instead.' };
+        }
+        catch (error) {
+            return { route: null, error: sanitizeError(error) };
+        }
     },
-    handler: function (params) { return __awaiter(void 0, void 0, void 0, function () {
-        var input, bridge, result, error_15;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    input = validateString(params.input, 'input', 10000);
-                    if (!input)
-                        return [2 /*return*/, { route: null, error: 'input is required (non-empty string, max 10KB)' }];
-                    return [4 /*yield*/, getBridge()];
-                case 1:
-                    bridge = _a.sent();
-                    return [4 /*yield*/, bridge.bridgeSemanticRoute({ input: input })];
-                case 2:
-                    result = _a.sent();
-                    return [2 /*return*/, result !== null && result !== void 0 ? result : { route: null, error: 'AgentDB bridge not available. Use hooks route instead.' }];
-                case 3:
-                    error_15 = _a.sent();
-                    return [2 /*return*/, { route: null, error: sanitizeError(error_15) }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 // ===== Export all tools =====
-export var agentdbTools = [
+export const agentdbTools = [
     agentdbHealth,
     agentdbControllers,
     agentdbPatternStore,