@cogitator-ai/memory 0.10.0 → 0.11.1

package/dist/knowledge-graph/sqlite-graph-adapter.js

@@ -1,4 +1,5 @@
 import { nanoid } from 'nanoid';
+import { unwrap } from '../result.js';
 export class SQLiteGraphAdapter {
     db = null;
     path;
@@ -12,10 +13,8 @@ export class SQLiteGraphAdapter {
         if (this.initialized)
             return;
         if (!this.db) {
-            let DatabaseCtor;
-            const betterSqlite = await import('better-sqlite3');
-            DatabaseCtor = betterSqlite.default;
-            this.db = new DatabaseCtor(this.path);
+            const Database = (await import('better-sqlite3')).default;
+            this.db = new Database(this.path);
             this.db.pragma('foreign_keys = ON');
             if (this.walMode && this.path !== ':memory:') {
                 this.db.pragma('journal_mode = WAL');
@@ -87,6 +86,15 @@ export class SQLiteGraphAdapter {
     failure(error) {
         return { success: false, error };
     }
+    async run(operation) {
+        try {
+            await this.initialize();
+            return await operation();
+        }
+        catch (err) {
+            return this.failure(err instanceof Error ? err.message : String(err));
+        }
+    }
     generateId(prefix) {
         return `${prefix}_${nanoid(12)}`;
     }
@@ -164,300 +172,313 @@ export class SQLiteGraphAdapter {
         return dot / denom;
     }
     async addNode(node) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const id = this.generateId('node');
-        const now = new Date();
-        const nowStr = now.toISOString();
-        db.prepare(`INSERT INTO graph_nodes
-       (id, agent_id, type, name, aliases, description, properties, embedding, confidence, source, metadata, access_count, created_at, updated_at, last_accessed_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`).run(id, node.agentId, node.type, node.name, JSON.stringify(node.aliases), node.description ?? null, JSON.stringify(node.properties), node.embedding ? JSON.stringify(node.embedding) : null, node.confidence, node.source, JSON.stringify(node.metadata ?? {}), nowStr, nowStr, nowStr);
-        return this.success({
-            ...node,
-            id,
-            createdAt: now,
-            updatedAt: now,
-            lastAccessedAt: now,
-            accessCount: 0,
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const id = this.generateId('node');
+            const now = new Date();
+            const nowStr = now.toISOString();
+            db.prepare(`INSERT INTO graph_nodes
+         (id, agent_id, type, name, aliases, description, properties, embedding, confidence, source, metadata, access_count, created_at, updated_at, last_accessed_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`).run(id, node.agentId, node.type, node.name, JSON.stringify(node.aliases), node.description ?? null, JSON.stringify(node.properties), node.embedding ? JSON.stringify(node.embedding) : null, node.confidence, node.source, JSON.stringify(node.metadata ?? {}), nowStr, nowStr, nowStr);
+            return this.success({
+                ...node,
+                id,
+                createdAt: now,
+                updatedAt: now,
+                lastAccessedAt: now,
+                accessCount: 0,
+            });
         });
     }
     async getNode(nodeId) {
-        await this.initialize();
-        const db = this.ensureDb();
-        db.prepare(`UPDATE graph_nodes SET last_accessed_at = ?, access_count = access_count + 1 WHERE id = ?`).run(new Date().toISOString(), nodeId);
-        const row = db.prepare(`SELECT * FROM graph_nodes WHERE id = ?`).get(nodeId);
-        if (!row)
-            return this.success(null);
-        return this.success(this.rowToNode(row));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            db.prepare(`UPDATE graph_nodes SET last_accessed_at = ?, access_count = access_count + 1 WHERE id = ?`).run(new Date().toISOString(), nodeId);
+            const row = db.prepare(`SELECT * FROM graph_nodes WHERE id = ?`).get(nodeId);
+            if (!row)
+                return this.success(null);
+            return this.success(this.rowToNode(row));
+        });
     }
     async getNodeByName(agentId, name) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const row = db
-            .prepare(`SELECT * FROM graph_nodes WHERE agent_id = ? AND name = ?`)
-            .get(agentId, name);
-        if (row)
-            return this.success(this.rowToNode(row));
-        const allRows = db
-            .prepare(`SELECT * FROM graph_nodes WHERE agent_id = ?`)
-            .all(agentId);
-        for (const r of allRows) {
-            const aliases = JSON.parse(r.aliases);
-            if (aliases.includes(name)) {
-                return this.success(this.rowToNode(r));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const row = db
+                .prepare(`SELECT * FROM graph_nodes WHERE agent_id = ? AND name = ?`)
+                .get(agentId, name);
+            if (row)
+                return this.success(this.rowToNode(row));
+            const allRows = db
+                .prepare(`SELECT * FROM graph_nodes WHERE agent_id = ?`)
+                .all(agentId);
+            for (const r of allRows) {
+                const aliases = JSON.parse(r.aliases);
+                if (aliases.includes(name)) {
+                    return this.success(this.rowToNode(r));
+                }
             }
-        }
-        return this.success(null);
+            return this.success(null);
+        });
     }
     async updateNode(nodeId, updates) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const setClauses = ['updated_at = ?'];
-        const params = [new Date().toISOString()];
-        if (updates.name !== undefined) {
-            setClauses.push('name = ?');
-            params.push(updates.name);
-        }
-        if (updates.aliases !== undefined) {
-            setClauses.push('aliases = ?');
-            params.push(JSON.stringify(updates.aliases));
-        }
-        if (updates.description !== undefined) {
-            setClauses.push('description = ?');
-            params.push(updates.description);
-        }
-        if (updates.properties !== undefined) {
-            setClauses.push('properties = ?');
-            params.push(JSON.stringify(updates.properties));
-        }
-        if (updates.confidence !== undefined) {
-            setClauses.push('confidence = ?');
-            params.push(updates.confidence);
-        }
-        if (updates.metadata !== undefined) {
-            setClauses.push('metadata = ?');
-            params.push(JSON.stringify(updates.metadata));
-        }
-        if (updates.embedding !== undefined) {
-            setClauses.push('embedding = ?');
-            params.push(JSON.stringify(updates.embedding));
-        }
-        params.push(nodeId);
-        const result = db
-            .prepare(`UPDATE graph_nodes SET ${setClauses.join(', ')} WHERE id = ?`)
-            .run(...params);
-        if (result.changes === 0) {
-            return this.failure(`Node not found: ${nodeId}`);
-        }
-        const row = db.prepare(`SELECT * FROM graph_nodes WHERE id = ?`).get(nodeId);
-        return this.success(this.rowToNode(row));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const setClauses = ['updated_at = ?'];
+            const params = [new Date().toISOString()];
+            if (updates.name !== undefined) {
+                setClauses.push('name = ?');
+                params.push(updates.name);
+            }
+            if (updates.aliases !== undefined) {
+                setClauses.push('aliases = ?');
+                params.push(JSON.stringify(updates.aliases));
+            }
+            if (updates.description !== undefined) {
+                setClauses.push('description = ?');
+                params.push(updates.description);
+            }
+            if (updates.properties !== undefined) {
+                setClauses.push('properties = ?');
+                params.push(JSON.stringify(updates.properties));
+            }
+            if (updates.confidence !== undefined) {
+                setClauses.push('confidence = ?');
+                params.push(updates.confidence);
+            }
+            if (updates.metadata !== undefined) {
+                setClauses.push('metadata = ?');
+                params.push(JSON.stringify(updates.metadata));
+            }
+            if (updates.embedding !== undefined) {
+                setClauses.push('embedding = ?');
+                params.push(JSON.stringify(updates.embedding));
+            }
+            params.push(nodeId);
+            const result = db
+                .prepare(`UPDATE graph_nodes SET ${setClauses.join(', ')} WHERE id = ?`)
+                .run(...params);
+            if (result.changes === 0) {
+                return this.failure(`Node not found: ${nodeId}`);
+            }
+            const row = db.prepare(`SELECT * FROM graph_nodes WHERE id = ?`).get(nodeId);
+            return this.success(this.rowToNode(row));
+        });
     }
     async deleteNode(nodeId) {
-        await this.initialize();
-        const db = this.ensureDb();
-        db.prepare(`DELETE FROM graph_nodes WHERE id = ?`).run(nodeId);
-        return this.success(undefined);
+        return this.run(async () => {
+            const db = this.ensureDb();
+            db.prepare(`DELETE FROM graph_nodes WHERE id = ?`).run(nodeId);
+            return this.success(undefined);
+        });
     }
     async queryNodes(query) {
-        await this.initialize();
-        const db = this.ensureDb();
-        let sql = `SELECT * FROM graph_nodes WHERE agent_id = ?`;
-        const params = [query.agentId];
-        if (query.types && query.types.length > 0) {
-            const placeholders = query.types.map(() => '?').join(', ');
-            sql += ` AND type IN (${placeholders})`;
-            params.push(...query.types);
-        }
-        if (query.namePattern) {
-            sql += ` AND name LIKE ? ESCAPE '\\'`;
-            params.push(`%${query.namePattern.replace(/[%_\\]/g, '\\$&')}%`);
-        }
-        if (query.minConfidence !== undefined) {
-            sql += ` AND confidence >= ?`;
-            params.push(query.minConfidence);
-        }
-        sql += ' ORDER BY access_count DESC, updated_at DESC';
-        if (query.limit) {
-            sql += ` LIMIT ?`;
-            params.push(query.limit);
-        }
-        const rows = db.prepare(sql).all(...params);
-        return this.success(rows.map((row) => this.rowToNode(row, query.includeEmbedding)));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            let sql = `SELECT * FROM graph_nodes WHERE agent_id = ?`;
+            const params = [query.agentId];
+            if (query.types && query.types.length > 0) {
+                const placeholders = query.types.map(() => '?').join(', ');
+                sql += ` AND type IN (${placeholders})`;
+                params.push(...query.types);
+            }
+            if (query.namePattern) {
+                sql += ` AND name LIKE ? ESCAPE '\\'`;
+                params.push(`%${query.namePattern.replace(/[%_\\]/g, '\\$&')}%`);
+            }
+            if (query.minConfidence !== undefined) {
+                sql += ` AND confidence >= ?`;
+                params.push(query.minConfidence);
+            }
+            sql += ' ORDER BY access_count DESC, updated_at DESC';
+            if (query.limit) {
+                sql += ` LIMIT ?`;
+                params.push(query.limit);
+            }
+            const rows = db.prepare(sql).all(...params);
+            return this.success(rows.map((row) => this.rowToNode(row, query.includeEmbedding)));
+        });
     }
     async searchNodesSemantic(options) {
-        await this.initialize();
-        const db = this.ensureDb();
-        if (!options.vector) {
-            return this.failure('searchNodesSemantic requires vector');
-        }
-        const limit = options.limit ?? 10;
-        const threshold = options.threshold ?? 0.7;
-        let sql = `SELECT * FROM graph_nodes WHERE agent_id = ? AND embedding IS NOT NULL`;
-        const params = [options.agentId];
-        if (options.entityTypes && options.entityTypes.length > 0) {
-            const placeholders = options.entityTypes.map(() => '?').join(', ');
-            sql += ` AND type IN (${placeholders})`;
-            params.push(...options.entityTypes);
-        }
-        const rows = db.prepare(sql).all(...params);
-        const scored = [];
-        for (const row of rows) {
-            if (!row.embedding)
-                continue;
-            const emb = JSON.parse(row.embedding);
-            const score = this.cosineSimilarity(options.vector, emb);
-            if (score >= threshold) {
-                scored.push({ ...this.rowToNode(row), score });
+        return this.run(async () => {
+            const db = this.ensureDb();
+            if (!options.vector) {
+                return this.failure('searchNodesSemantic requires vector');
             }
-        }
-        scored.sort((a, b) => b.score - a.score);
-        return this.success(scored.slice(0, limit));
+            const limit = options.limit ?? 10;
+            const threshold = options.threshold ?? 0.7;
+            let sql = `SELECT * FROM graph_nodes WHERE agent_id = ? AND embedding IS NOT NULL`;
+            const params = [options.agentId];
+            if (options.entityTypes && options.entityTypes.length > 0) {
+                const placeholders = options.entityTypes.map(() => '?').join(', ');
+                sql += ` AND type IN (${placeholders})`;
+                params.push(...options.entityTypes);
+            }
+            const rows = db.prepare(sql).all(...params);
+            const scored = [];
+            for (const row of rows) {
+                if (!row.embedding)
+                    continue;
+                const emb = JSON.parse(row.embedding);
+                const score = this.cosineSimilarity(options.vector, emb);
+                if (score >= threshold) {
+                    scored.push({ ...this.rowToNode(row), score });
+                }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            return this.success(scored.slice(0, limit));
+        });
     }
     async addEdge(edge) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const id = this.generateId('edge');
-        const now = new Date();
-        const nowStr = now.toISOString();
-        db.prepare(`INSERT INTO graph_edges
-       (id, agent_id, source_node_id, target_node_id, type, label, weight, bidirectional, properties, confidence, source, valid_from, valid_until, metadata, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, edge.agentId, edge.sourceNodeId, edge.targetNodeId, edge.type, edge.label ?? null, edge.weight, edge.bidirectional ? 1 : 0, JSON.stringify(edge.properties), edge.confidence, edge.source, edge.validFrom?.toISOString() ?? null, edge.validUntil?.toISOString() ?? null, JSON.stringify(edge.metadata ?? {}), nowStr, nowStr);
-        return this.success({
-            ...edge,
-            id,
-            createdAt: now,
-            updatedAt: now,
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const id = this.generateId('edge');
+            const now = new Date();
+            const nowStr = now.toISOString();
+            db.prepare(`INSERT INTO graph_edges
+         (id, agent_id, source_node_id, target_node_id, type, label, weight, bidirectional, properties, confidence, source, valid_from, valid_until, metadata, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, edge.agentId, edge.sourceNodeId, edge.targetNodeId, edge.type, edge.label ?? null, edge.weight, edge.bidirectional ? 1 : 0, JSON.stringify(edge.properties), edge.confidence, edge.source, edge.validFrom?.toISOString() ?? null, edge.validUntil?.toISOString() ?? null, JSON.stringify(edge.metadata ?? {}), nowStr, nowStr);
+            return this.success({
+                ...edge,
+                id,
+                createdAt: now,
+                updatedAt: now,
+            });
         });
     }
     async getEdge(edgeId) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const row = db.prepare(`SELECT * FROM graph_edges WHERE id = ?`).get(edgeId);
-        if (!row)
-            return this.success(null);
-        return this.success(this.rowToEdge(row));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const row = db.prepare(`SELECT * FROM graph_edges WHERE id = ?`).get(edgeId);
+            if (!row)
+                return this.success(null);
+            return this.success(this.rowToEdge(row));
+        });
     }
     async getEdgesBetween(sourceNodeId, targetNodeId) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const rows = db
-            .prepare(`SELECT * FROM graph_edges
-         WHERE (source_node_id = ? AND target_node_id = ?)
-            OR (bidirectional = 1 AND source_node_id = ? AND target_node_id = ?)`)
-            .all(sourceNodeId, targetNodeId, targetNodeId, sourceNodeId);
-        return this.success(rows.map((row) => this.rowToEdge(row)));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const rows = db
+                .prepare(`SELECT * FROM graph_edges
+           WHERE (source_node_id = ? AND target_node_id = ?)
+              OR (bidirectional = 1 AND source_node_id = ? AND target_node_id = ?)`)
+                .all(sourceNodeId, targetNodeId, targetNodeId, sourceNodeId);
+            return this.success(rows.map((row) => this.rowToEdge(row)));
+        });
     }
     async updateEdge(edgeId, updates) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const setClauses = ['updated_at = ?'];
-        const params = [new Date().toISOString()];
-        if (updates.weight !== undefined) {
-            setClauses.push('weight = ?');
-            params.push(updates.weight);
-        }
-        if (updates.label !== undefined) {
-            setClauses.push('label = ?');
-            params.push(updates.label);
-        }
-        if (updates.properties !== undefined) {
-            setClauses.push('properties = ?');
-            params.push(JSON.stringify(updates.properties));
-        }
-        if (updates.confidence !== undefined) {
-            setClauses.push('confidence = ?');
-            params.push(updates.confidence);
-        }
-        if (updates.validFrom !== undefined) {
-            setClauses.push('valid_from = ?');
-            params.push(updates.validFrom.toISOString());
-        }
-        if (updates.validUntil !== undefined) {
-            setClauses.push('valid_until = ?');
-            params.push(updates.validUntil.toISOString());
-        }
-        if (updates.metadata !== undefined) {
-            setClauses.push('metadata = ?');
-            params.push(JSON.stringify(updates.metadata));
-        }
-        params.push(edgeId);
-        const result = db
-            .prepare(`UPDATE graph_edges SET ${setClauses.join(', ')} WHERE id = ?`)
-            .run(...params);
-        if (result.changes === 0) {
-            return this.failure(`Edge not found: ${edgeId}`);
-        }
-        const row = db.prepare(`SELECT * FROM graph_edges WHERE id = ?`).get(edgeId);
-        return this.success(this.rowToEdge(row));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const setClauses = ['updated_at = ?'];
+            const params = [new Date().toISOString()];
+            if (updates.weight !== undefined) {
+                setClauses.push('weight = ?');
+                params.push(updates.weight);
+            }
+            if (updates.label !== undefined) {
+                setClauses.push('label = ?');
+                params.push(updates.label);
+            }
+            if (updates.properties !== undefined) {
+                setClauses.push('properties = ?');
+                params.push(JSON.stringify(updates.properties));
+            }
+            if (updates.confidence !== undefined) {
+                setClauses.push('confidence = ?');
+                params.push(updates.confidence);
+            }
+            if (updates.validFrom !== undefined) {
+                setClauses.push('valid_from = ?');
+                params.push(updates.validFrom.toISOString());
+            }
+            if (updates.validUntil !== undefined) {
+                setClauses.push('valid_until = ?');
+                params.push(updates.validUntil.toISOString());
+            }
+            if (updates.metadata !== undefined) {
+                setClauses.push('metadata = ?');
+                params.push(JSON.stringify(updates.metadata));
+            }
+            params.push(edgeId);
+            const result = db
+                .prepare(`UPDATE graph_edges SET ${setClauses.join(', ')} WHERE id = ?`)
+                .run(...params);
+            if (result.changes === 0) {
+                return this.failure(`Edge not found: ${edgeId}`);
+            }
+            const row = db.prepare(`SELECT * FROM graph_edges WHERE id = ?`).get(edgeId);
+            return this.success(this.rowToEdge(row));
+        });
     }
     async deleteEdge(edgeId) {
-        await this.initialize();
-        const db = this.ensureDb();
-        db.prepare(`DELETE FROM graph_edges WHERE id = ?`).run(edgeId);
-        return this.success(undefined);
+        return this.run(async () => {
+            const db = this.ensureDb();
+            db.prepare(`DELETE FROM graph_edges WHERE id = ?`).run(edgeId);
+            return this.success(undefined);
+        });
     }
     async queryEdges(query) {
-        await this.initialize();
-        const db = this.ensureDb();
-        let sql = `SELECT * FROM graph_edges WHERE agent_id = ?`;
-        const params = [query.agentId];
-        if (query.sourceNodeId) {
-            sql += ` AND source_node_id = ?`;
-            params.push(query.sourceNodeId);
-        }
-        if (query.targetNodeId) {
-            sql += ` AND target_node_id = ?`;
-            params.push(query.targetNodeId);
-        }
-        if (query.types && query.types.length > 0) {
-            const placeholders = query.types.map(() => '?').join(', ');
-            sql += ` AND type IN (${placeholders})`;
-            params.push(...query.types);
-        }
-        if (query.minWeight !== undefined) {
-            sql += ` AND weight >= ?`;
-            params.push(query.minWeight);
-        }
-        if (query.minConfidence !== undefined) {
-            sql += ` AND confidence >= ?`;
-            params.push(query.minConfidence);
-        }
-        if (query.bidirectionalOnly) {
-            sql += ' AND bidirectional = 1';
-        }
-        sql += ' ORDER BY weight DESC, confidence DESC';
-        if (query.limit) {
-            sql += ` LIMIT ?`;
-            params.push(query.limit);
-        }
-        const rows = db.prepare(sql).all(...params);
-        return this.success(rows.map((row) => this.rowToEdge(row)));
+        return this.run(async () => {
+            const db = this.ensureDb();
+            let sql = `SELECT * FROM graph_edges WHERE agent_id = ?`;
+            const params = [query.agentId];
+            if (query.sourceNodeId) {
+                sql += ` AND source_node_id = ?`;
+                params.push(query.sourceNodeId);
+            }
+            if (query.targetNodeId) {
+                sql += ` AND target_node_id = ?`;
+                params.push(query.targetNodeId);
+            }
+            if (query.types && query.types.length > 0) {
+                const placeholders = query.types.map(() => '?').join(', ');
+                sql += ` AND type IN (${placeholders})`;
+                params.push(...query.types);
+            }
+            if (query.minWeight !== undefined) {
+                sql += ` AND weight >= ?`;
+                params.push(query.minWeight);
+            }
+            if (query.minConfidence !== undefined) {
+                sql += ` AND confidence >= ?`;
+                params.push(query.minConfidence);
+            }
+            if (query.bidirectionalOnly) {
+                sql += ' AND bidirectional = 1';
+            }
+            sql += ' ORDER BY weight DESC, confidence DESC';
+            if (query.limit) {
+                sql += ` LIMIT ?`;
+                params.push(query.limit);
+            }
+            const rows = db.prepare(sql).all(...params);
+            return this.success(rows.map((row) => this.rowToEdge(row)));
+        });
     }
     async traverse(options) {
-        await this.initialize();
-        const visited = new Set();
-        const visitedEdges = new Set();
-        const paths = [];
-        const allNodes = [];
-        const allEdges = [];
-        const startNodeResult = await this.getNode(options.startNodeId);
-        if (!startNodeResult.success || !startNodeResult.data) {
-            return this.failure(`Start node not found: ${options.startNodeId}`);
-        }
-        const startNode = startNodeResult.data;
-        visited.add(startNode.id);
-        allNodes.push(startNode);
-        await this.traverseRecursive(startNode, [], [], 0, options, visited, visitedEdges, paths, allNodes, allEdges);
-        let actualMaxDepth = 0;
-        for (const p of paths) {
-            if (p.length > actualMaxDepth)
-                actualMaxDepth = p.length;
-        }
-        return this.success({
-            paths,
-            visitedNodes: allNodes,
-            visitedEdges: allEdges,
-            depth: actualMaxDepth,
+        return this.run(async () => {
+            const visited = new Set();
+            const visitedEdges = new Set();
+            const paths = [];
+            const allNodes = [];
+            const allEdges = [];
+            const startNode = unwrap(await this.getNode(options.startNodeId));
+            if (!startNode) {
+                return this.failure(`Start node not found: ${options.startNodeId}`);
+            }
+            visited.add(startNode.id);
+            allNodes.push(startNode);
+            await this.traverseRecursive(startNode, [], [], 0, options, visited, visitedEdges, paths, allNodes, allEdges);
+            let actualMaxDepth = 0;
+            for (const p of paths) {
+                if (p.length > actualMaxDepth)
+                    actualMaxDepth = p.length;
+            }
+            return this.success({
+                paths,
+                visitedNodes: allNodes,
+                visitedEdges: allEdges,
+                depth: actualMaxDepth,
+            });
         });
     }
     async traverseRecursive(currentNode, pathNodes, pathEdges, currentDepth, options, visited, visitedEdges, paths, allNodes, allEdges) {
@@ -474,11 +495,9 @@ export class SQLiteGraphAdapter {
         }
         if (options.limit && paths.length >= options.limit)
             return;
-        const neighborsResult = await this.getNeighbors(currentNode.id, options.direction);
-        if (!neighborsResult.success)
-            return;
+        const neighbors = unwrap(await this.getNeighbors(currentNode.id, options.direction));
         let hasUnvisitedNeighbors = false;
-        for (const { node, edge } of neighborsResult.data) {
+        for (const { node, edge } of neighbors) {
             if (options.edgeTypes && !options.edgeTypes.includes(edge.type))
                 continue;
             if (options.minEdgeWeight !== undefined && edge.weight < options.minEdgeWeight)
@@ -506,188 +525,191 @@ export class SQLiteGraphAdapter {
         }
     }
     async findShortestPath(_agentId, startNodeId, endNodeId, maxDepth = 5) {
-        await this.initialize();
-        if (startNodeId === endNodeId) {
-            const nodeResult = await this.getNode(startNodeId);
-            if (!nodeResult.success || !nodeResult.data)
-                return this.success(null);
-            return this.success({
-                nodes: [nodeResult.data],
-                edges: [],
-                totalWeight: 0,
-                length: 0,
-            });
-        }
-        const queue = [{ nodeId: startNodeId, pathNodeIds: [startNodeId], pathEdgeIds: [], totalWeight: 0 }];
-        const visited = new Set([startNodeId]);
-        while (queue.length > 0) {
-            const current = queue.shift();
-            if (current.pathEdgeIds.length >= maxDepth)
-                continue;
-            const neighborsResult = await this.getNeighbors(current.nodeId, 'both');
-            if (!neighborsResult.success)
-                continue;
-            for (const { node, edge } of neighborsResult.data) {
-                if (visited.has(node.id))
+        return this.run(async () => {
+            if (startNodeId === endNodeId) {
+                const node = unwrap(await this.getNode(startNodeId));
+                if (!node)
+                    return this.success(null);
+                return this.success({
+                    nodes: [node],
+                    edges: [],
+                    totalWeight: 0,
+                    length: 0,
+                });
+            }
+            const queue = [{ nodeId: startNodeId, pathNodeIds: [startNodeId], pathEdgeIds: [], totalWeight: 0 }];
+            const visited = new Set([startNodeId]);
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (current.pathEdgeIds.length >= maxDepth)
                     continue;
-                const newPath = {
-                    nodeId: node.id,
-                    pathNodeIds: [...current.pathNodeIds, node.id],
-                    pathEdgeIds: [...current.pathEdgeIds, edge.id],
-                    totalWeight: current.totalWeight + edge.weight,
-                };
-                if (node.id === endNodeId) {
-                    const nodes = [];
-                    for (const nid of newPath.pathNodeIds) {
-                        const nr = await this.getNode(nid);
-                        if (nr.success && nr.data)
-                            nodes.push(nr.data);
+                const neighbors = unwrap(await this.getNeighbors(current.nodeId, 'both'));
+                for (const { node, edge } of neighbors) {
+                    if (visited.has(node.id))
+                        continue;
+                    const newPath = {
+                        nodeId: node.id,
+                        pathNodeIds: [...current.pathNodeIds, node.id],
+                        pathEdgeIds: [...current.pathEdgeIds, edge.id],
+                        totalWeight: current.totalWeight + edge.weight,
+                    };
+                    if (node.id === endNodeId) {
+                        const nodes = [];
+                        for (const nid of newPath.pathNodeIds) {
+                            const pathNode = unwrap(await this.getNode(nid));
+                            if (pathNode)
+                                nodes.push(pathNode);
+                        }
+                        const edges = [];
+                        for (const eid of newPath.pathEdgeIds) {
+                            const pathEdge = unwrap(await this.getEdge(eid));
+                            if (pathEdge)
+                                edges.push(pathEdge);
+                        }
+                        return this.success({
+                            nodes,
+                            edges,
+                            totalWeight: newPath.totalWeight,
+                            length: edges.length,
+                        });
                     }
-                    const edges = [];
-                    for (const eid of newPath.pathEdgeIds) {
-                        const er = await this.getEdge(eid);
-                        if (er.success && er.data)
-                            edges.push(er.data);
-                    }
-                    return this.success({
-                        nodes,
-                        edges,
-                        totalWeight: newPath.totalWeight,
-                        length: edges.length,
-                    });
+                    visited.add(node.id);
+                    queue.push(newPath);
                 }
-                visited.add(node.id);
-                queue.push(newPath);
             }
-        }
-        return this.success(null);
+            return this.success(null);
+        });
     }
     async getNeighbors(nodeId, direction = 'both') {
-        await this.initialize();
-        const db = this.ensureDb();
-        const selectCols = `
-      n.id, n.agent_id, n.type, n.name, n.aliases, n.description,
-      n.properties, n.embedding, n.confidence, n.source, n.metadata,
-      n.created_at, n.updated_at, n.last_accessed_at, n.access_count,
-      e.id as edge_id, e.agent_id as edge_agent_id, e.type as edge_type,
-      e.source_node_id as edge_source_node_id, e.target_node_id as edge_target_node_id,
-      e.label as edge_label, e.weight as edge_weight, e.bidirectional as edge_bidirectional,
-      e.properties as edge_properties, e.confidence as edge_confidence,
-      e.source as edge_source, e.valid_from as edge_valid_from, e.valid_until as edge_valid_until,
-      e.metadata as edge_metadata, e.created_at as edge_created_at, e.updated_at as edge_updated_at
-    `;
-        let sql;
-        if (direction === 'outgoing') {
-            sql = `
-        SELECT ${selectCols}
-        FROM graph_edges e
-        JOIN graph_nodes n ON n.id = e.target_node_id
-        WHERE e.source_node_id = ?
-        UNION ALL
-        SELECT ${selectCols}
-        FROM graph_edges e
-        JOIN graph_nodes n ON n.id = e.source_node_id
-        WHERE e.target_node_id = ? AND e.bidirectional = 1
-      `;
-        }
-        else if (direction === 'incoming') {
-            sql = `
-        SELECT ${selectCols}
-        FROM graph_edges e
-        JOIN graph_nodes n ON n.id = e.source_node_id
-        WHERE e.target_node_id = ?
-        UNION ALL
-        SELECT ${selectCols}
-        FROM graph_edges e
-        JOIN graph_nodes n ON n.id = e.target_node_id
-        WHERE e.source_node_id = ? AND e.bidirectional = 1
-      `;
-        }
-        else {
-            sql = `
-        SELECT ${selectCols}
-        FROM graph_edges e
-        JOIN graph_nodes n ON n.id = e.target_node_id
-        WHERE e.source_node_id = ?
-        UNION ALL
-        SELECT ${selectCols}
-        FROM graph_edges e
-        JOIN graph_nodes n ON n.id = e.source_node_id
-        WHERE e.target_node_id = ?
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const selectCols = `
+        n.id, n.agent_id, n.type, n.name, n.aliases, n.description,
+        n.properties, n.embedding, n.confidence, n.source, n.metadata,
+        n.created_at, n.updated_at, n.last_accessed_at, n.access_count,
+        e.id as edge_id, e.agent_id as edge_agent_id, e.type as edge_type,
+        e.source_node_id as edge_source_node_id, e.target_node_id as edge_target_node_id,
+        e.label as edge_label, e.weight as edge_weight, e.bidirectional as edge_bidirectional,
+        e.properties as edge_properties, e.confidence as edge_confidence,
+        e.source as edge_source, e.valid_from as edge_valid_from, e.valid_until as edge_valid_until,
+        e.metadata as edge_metadata, e.created_at as edge_created_at, e.updated_at as edge_updated_at
       `;
-        }
-        const rows = db.prepare(sql).all(nodeId, nodeId);
-        return this.success(rows.map((row) => ({
-            node: this.rowToNode(row),
-            edge: this.neighborRowToEdge(row),
-        })));
+            let sql;
+            if (direction === 'outgoing') {
+                sql = `
+          SELECT ${selectCols}
+          FROM graph_edges e
+          JOIN graph_nodes n ON n.id = e.target_node_id
+          WHERE e.source_node_id = ?
+          UNION ALL
+          SELECT ${selectCols}
+          FROM graph_edges e
+          JOIN graph_nodes n ON n.id = e.source_node_id
+          WHERE e.target_node_id = ? AND e.bidirectional = 1
+        `;
+            }
+            else if (direction === 'incoming') {
+                sql = `
+          SELECT ${selectCols}
+          FROM graph_edges e
+          JOIN graph_nodes n ON n.id = e.source_node_id
+          WHERE e.target_node_id = ?
+          UNION ALL
+          SELECT ${selectCols}
+          FROM graph_edges e
+          JOIN graph_nodes n ON n.id = e.target_node_id
+          WHERE e.source_node_id = ? AND e.bidirectional = 1
+        `;
+            }
+            else {
+                sql = `
+          SELECT ${selectCols}
+          FROM graph_edges e
+          JOIN graph_nodes n ON n.id = e.target_node_id
+          WHERE e.source_node_id = ?
+          UNION ALL
+          SELECT ${selectCols}
+          FROM graph_edges e
+          JOIN graph_nodes n ON n.id = e.source_node_id
+          WHERE e.target_node_id = ?
+        `;
+            }
+            const rows = db.prepare(sql).all(nodeId, nodeId);
+            return this.success(rows.map((row) => ({
+                node: this.rowToNode(row),
+                edge: this.neighborRowToEdge(row),
+            })));
+        });
     }
     async mergeNodes(targetNodeId, sourceNodeIds) {
-        await this.initialize();
-        const db = this.ensureDb();
-        for (const sourceId of sourceNodeIds) {
-            const sourceNode = await this.getNode(sourceId);
-            db.prepare(`UPDATE graph_edges SET source_node_id = ? WHERE source_node_id = ?`).run(targetNodeId, sourceId);
-            db.prepare(`UPDATE graph_edges SET target_node_id = ? WHERE target_node_id = ?`).run(targetNodeId, sourceId);
-            db.prepare(`DELETE FROM graph_edges WHERE source_node_id = ? AND target_node_id = ?`).run(targetNodeId, targetNodeId);
-            if (sourceNode.success && sourceNode.data) {
-                const targetRow = db
-                    .prepare(`SELECT aliases FROM graph_nodes WHERE id = ?`)
-                    .get(targetNodeId);
-                if (targetRow) {
-                    const currentAliases = JSON.parse(targetRow.aliases);
-                    const newAliases = [...currentAliases, sourceNode.data.name, ...sourceNode.data.aliases];
-                    const uniqueAliases = [...new Set(newAliases)];
-                    db.prepare(`UPDATE graph_nodes SET aliases = ? WHERE id = ?`).run(JSON.stringify(uniqueAliases), targetNodeId);
+        return this.run(async () => {
+            const db = this.ensureDb();
+            for (const sourceId of sourceNodeIds) {
+                const sourceNode = unwrap(await this.getNode(sourceId));
+                db.prepare(`UPDATE graph_edges SET source_node_id = ? WHERE source_node_id = ?`).run(targetNodeId, sourceId);
+                db.prepare(`UPDATE graph_edges SET target_node_id = ? WHERE target_node_id = ?`).run(targetNodeId, sourceId);
+                db.prepare(`DELETE FROM graph_edges WHERE source_node_id = ? AND target_node_id = ?`).run(targetNodeId, targetNodeId);
+                if (sourceNode) {
+                    const targetRow = db
+                        .prepare(`SELECT aliases FROM graph_nodes WHERE id = ?`)
+                        .get(targetNodeId);
+                    if (targetRow) {
+                        const currentAliases = JSON.parse(targetRow.aliases);
+                        const newAliases = [...currentAliases, sourceNode.name, ...sourceNode.aliases];
+                        const uniqueAliases = [...new Set(newAliases)];
+                        db.prepare(`UPDATE graph_nodes SET aliases = ? WHERE id = ?`).run(JSON.stringify(uniqueAliases), targetNodeId);
+                    }
                 }
+                db.prepare(`DELETE FROM graph_nodes WHERE id = ?`).run(sourceId);
             }
-            db.prepare(`DELETE FROM graph_nodes WHERE id = ?`).run(sourceId);
-        }
-        const mergedNode = await this.getNode(targetNodeId);
-        if (!mergedNode.success || !mergedNode.data) {
-            return this.failure(`Target node not found: ${targetNodeId}`);
-        }
-        return this.success(mergedNode.data);
+            const mergedNode = unwrap(await this.getNode(targetNodeId));
+            if (!mergedNode) {
+                return this.failure(`Target node not found: ${targetNodeId}`);
+            }
+            return this.success(mergedNode);
+        });
     }
     async clearGraph(agentId) {
-        await this.initialize();
-        const db = this.ensureDb();
-        db.prepare(`DELETE FROM graph_edges WHERE agent_id = ?`).run(agentId);
-        db.prepare(`DELETE FROM graph_nodes WHERE agent_id = ?`).run(agentId);
-        return this.success(undefined);
+        return this.run(async () => {
+            const db = this.ensureDb();
+            db.prepare(`DELETE FROM graph_edges WHERE agent_id = ?`).run(agentId);
+            db.prepare(`DELETE FROM graph_nodes WHERE agent_id = ?`).run(agentId);
+            return this.success(undefined);
+        });
     }
     async getGraphStats(agentId) {
-        await this.initialize();
-        const db = this.ensureDb();
-        const nodeCountRow = db
-            .prepare(`SELECT COUNT(*) as count FROM graph_nodes WHERE agent_id = ?`)
-            .get(agentId);
-        const edgeCountRow = db
-            .prepare(`SELECT COUNT(*) as count FROM graph_edges WHERE agent_id = ?`)
-            .get(agentId);
-        const nodesByTypeRows = db
-            .prepare(`SELECT type, COUNT(*) as count FROM graph_nodes WHERE agent_id = ? GROUP BY type`)
-            .all(agentId);
-        const edgesByTypeRows = db
-            .prepare(`SELECT type, COUNT(*) as count FROM graph_edges WHERE agent_id = ? GROUP BY type`)
-            .all(agentId);
-        const nodeCount = nodeCountRow.count;
-        const edgeCount = edgeCountRow.count;
-        const nodesByType = {};
-        for (const row of nodesByTypeRows) {
-            nodesByType[row.type] = row.count;
-        }
-        const edgesByType = {};
-        for (const row of edgesByTypeRows) {
-            edgesByType[row.type] = row.count;
-        }
-        return this.success({
-            nodeCount,
-            edgeCount,
-            nodesByType: nodesByType,
-            edgesByType: edgesByType,
-            averageEdgesPerNode: nodeCount > 0 ? edgeCount / nodeCount : 0,
-            maxDepth: 0,
+        return this.run(async () => {
+            const db = this.ensureDb();
+            const nodeCountRow = db
+                .prepare(`SELECT COUNT(*) as count FROM graph_nodes WHERE agent_id = ?`)
+                .get(agentId);
+            const edgeCountRow = db
+                .prepare(`SELECT COUNT(*) as count FROM graph_edges WHERE agent_id = ?`)
+                .get(agentId);
+            const nodesByTypeRows = db
+                .prepare(`SELECT type, COUNT(*) as count FROM graph_nodes WHERE agent_id = ? GROUP BY type`)
+                .all(agentId);
+            const edgesByTypeRows = db
+                .prepare(`SELECT type, COUNT(*) as count FROM graph_edges WHERE agent_id = ? GROUP BY type`)
+                .all(agentId);
+            const nodeCount = nodeCountRow.count;
+            const edgeCount = edgeCountRow.count;
+            const nodesByType = {};
+            for (const row of nodesByTypeRows) {
+                nodesByType[row.type] = row.count;
+            }
+            const edgesByType = {};
+            for (const row of edgesByTypeRows) {
+                edgesByType[row.type] = row.count;
+            }
+            return this.success({
+                nodeCount,
+                edgeCount,
+                nodesByType: nodesByType,
+                edgesByType: edgesByType,
+                averageEdgesPerNode: nodeCount > 0 ? edgeCount / nodeCount : 0,
+                maxDepth: 0,
+            });
         });
     }
 }