@cogitator-ai/memory 0.10.0 → 0.11.1

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

@@ -1,4 +1,6 @@
 import { nanoid } from 'nanoid';
+import { unwrap } from '../result.js';
+import { ensureHnswCosineIndex } from '../adapters/pgvector.js';
 export class PostgresGraphAdapter {
     pool;
     schema;
@@ -95,11 +97,12 @@ export class PostgresGraphAdapter {
       ON ${this.schema}.graph_edges(agent_id, type)
     `);
         try {
-            await this.pool.query(`
-        CREATE INDEX IF NOT EXISTS idx_graph_nodes_embedding
-        ON ${this.schema}.graph_nodes
-        USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100)
-      `);
+            await ensureHnswCosineIndex(this.pool, {
+                schema: this.schema,
+                table: 'graph_nodes',
+                column: 'embedding',
+                index: 'idx_graph_nodes_embedding',
+            });
         }
         catch { }
     }
@@ -109,308 +112,326 @@ export class PostgresGraphAdapter {
     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)}`;
     }
     async addNode(node) {
-        await this.initialize();
-        const id = this.generateId('node');
-        const now = new Date();
-        const embeddingStr = node.embedding ? `[${node.embedding.join(',')}]` : null;
-        await this.pool.query(`INSERT INTO ${this.schema}.graph_nodes
-       (id, agent_id, type, name, aliases, description, properties, embedding, confidence, source, metadata, created_at, updated_at, last_accessed_at, access_count)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $12, $12, 0)`, [
-            id,
-            node.agentId,
-            node.type,
-            node.name,
-            node.aliases,
-            node.description ?? null,
-            node.properties,
-            embeddingStr,
-            node.confidence,
-            node.source,
-            node.metadata ?? {},
-            now,
-        ]);
-        return this.success({
-            ...node,
-            id,
-            createdAt: now,
-            updatedAt: now,
-            lastAccessedAt: now,
-            accessCount: 0,
+        return this.run(async () => {
+            const id = this.generateId('node');
+            const now = new Date();
+            const embeddingStr = node.embedding ? `[${node.embedding.join(',')}]` : null;
+            await this.pool.query(`INSERT INTO ${this.schema}.graph_nodes
+         (id, agent_id, type, name, aliases, description, properties, embedding, confidence, source, metadata, created_at, updated_at, last_accessed_at, access_count)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $12, $12, 0)`, [
+                id,
+                node.agentId,
+                node.type,
+                node.name,
+                node.aliases,
+                node.description ?? null,
+                node.properties,
+                embeddingStr,
+                node.confidence,
+                node.source,
+                node.metadata ?? {},
+                now,
+            ]);
+            return this.success({
+                ...node,
+                id,
+                createdAt: now,
+                updatedAt: now,
+                lastAccessedAt: now,
+                accessCount: 0,
+            });
         });
     }
     async getNode(nodeId) {
-        await this.initialize();
-        await this.pool.query(`UPDATE ${this.schema}.graph_nodes
-       SET last_accessed_at = NOW(), access_count = access_count + 1
-       WHERE id = $1`, [nodeId]);
-        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_nodes WHERE id = $1`, [
-            nodeId,
-        ]);
-        if (result.rows.length === 0)
-            return this.success(null);
-        return this.success(this.rowToNode(result.rows[0]));
+        return this.run(async () => {
+            await this.pool.query(`UPDATE ${this.schema}.graph_nodes
+         SET last_accessed_at = NOW(), access_count = access_count + 1
+         WHERE id = $1`, [nodeId]);
+            const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_nodes WHERE id = $1`, [nodeId]);
+            if (result.rows.length === 0)
+                return this.success(null);
+            return this.success(this.rowToNode(result.rows[0]));
+        });
     }
     async getNodeByName(agentId, name) {
-        await this.initialize();
-        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_nodes
-       WHERE agent_id = $1 AND (name = $2 OR $2 = ANY(aliases))`, [agentId, name]);
-        if (result.rows.length === 0)
-            return this.success(null);
-        return this.success(this.rowToNode(result.rows[0]));
+        return this.run(async () => {
+            const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_nodes
+         WHERE agent_id = $1 AND (name = $2 OR $2 = ANY(aliases))`, [agentId, name]);
+            if (result.rows.length === 0)
+                return this.success(null);
+            return this.success(this.rowToNode(result.rows[0]));
+        });
     }
     async updateNode(nodeId, updates) {
-        await this.initialize();
-        const setClauses = ['updated_at = NOW()'];
-        const params = [];
-        let paramIndex = 1;
-        if (updates.name !== undefined) {
-            setClauses.push(`name = $${paramIndex++}`);
-            params.push(updates.name);
-        }
-        if (updates.aliases !== undefined) {
-            setClauses.push(`aliases = $${paramIndex++}`);
-            params.push(updates.aliases);
-        }
-        if (updates.description !== undefined) {
-            setClauses.push(`description = $${paramIndex++}`);
-            params.push(updates.description);
-        }
-        if (updates.properties !== undefined) {
-            setClauses.push(`properties = $${paramIndex++}`);
-            params.push(updates.properties);
-        }
-        if (updates.confidence !== undefined) {
-            setClauses.push(`confidence = $${paramIndex++}`);
-            params.push(updates.confidence);
-        }
-        if (updates.metadata !== undefined) {
-            setClauses.push(`metadata = $${paramIndex++}`);
-            params.push(updates.metadata);
-        }
-        if (updates.embedding !== undefined) {
-            setClauses.push(`embedding = $${paramIndex++}`);
-            params.push(`[${updates.embedding.join(',')}]`);
-        }
-        params.push(nodeId);
-        const result = await this.pool.query(`UPDATE ${this.schema}.graph_nodes SET ${setClauses.join(', ')} WHERE id = $${paramIndex} RETURNING *`, params);
-        if (result.rows.length === 0) {
-            return this.failure(`Node not found: ${nodeId}`);
-        }
-        return this.success(this.rowToNode(result.rows[0]));
+        return this.run(async () => {
+            const setClauses = ['updated_at = NOW()'];
+            const params = [];
+            let paramIndex = 1;
+            if (updates.name !== undefined) {
+                setClauses.push(`name = $${paramIndex++}`);
+                params.push(updates.name);
+            }
+            if (updates.aliases !== undefined) {
+                setClauses.push(`aliases = $${paramIndex++}`);
+                params.push(updates.aliases);
+            }
+            if (updates.description !== undefined) {
+                setClauses.push(`description = $${paramIndex++}`);
+                params.push(updates.description);
+            }
+            if (updates.properties !== undefined) {
+                setClauses.push(`properties = $${paramIndex++}`);
+                params.push(updates.properties);
+            }
+            if (updates.confidence !== undefined) {
+                setClauses.push(`confidence = $${paramIndex++}`);
+                params.push(updates.confidence);
+            }
+            if (updates.metadata !== undefined) {
+                setClauses.push(`metadata = $${paramIndex++}`);
+                params.push(updates.metadata);
+            }
+            if (updates.embedding !== undefined) {
+                setClauses.push(`embedding = $${paramIndex++}`);
+                params.push(`[${updates.embedding.join(',')}]`);
+            }
+            params.push(nodeId);
+            const result = await this.pool.query(`UPDATE ${this.schema}.graph_nodes SET ${setClauses.join(', ')} WHERE id = $${paramIndex} RETURNING *`, params);
+            if (result.rows.length === 0) {
+                return this.failure(`Node not found: ${nodeId}`);
+            }
+            return this.success(this.rowToNode(result.rows[0]));
+        });
     }
     async deleteNode(nodeId) {
-        await this.initialize();
-        await this.pool.query(`DELETE FROM ${this.schema}.graph_nodes WHERE id = $1`, [nodeId]);
-        return this.success(undefined);
+        return this.run(async () => {
+            await this.pool.query(`DELETE FROM ${this.schema}.graph_nodes WHERE id = $1`, [nodeId]);
+            return this.success(undefined);
+        });
     }
     async queryNodes(query) {
-        await this.initialize();
-        let sql = `SELECT * FROM ${this.schema}.graph_nodes WHERE agent_id = $1`;
-        const params = [query.agentId];
-        let paramIndex = 2;
-        if (query.types && query.types.length > 0) {
-            sql += ` AND type = ANY($${paramIndex++})`;
-            params.push(query.types);
-        }
-        if (query.namePattern) {
-            sql += ` AND name ILIKE $${paramIndex++}`;
-            params.push(`%${query.namePattern.replace(/[%_\\]/g, '\\$&')}%`);
-        }
-        if (query.minConfidence !== undefined) {
-            sql += ` AND confidence >= $${paramIndex++}`;
-            params.push(query.minConfidence);
-        }
-        sql += ' ORDER BY access_count DESC, updated_at DESC';
-        if (query.limit) {
-            sql += ` LIMIT $${paramIndex}`;
-            params.push(query.limit);
-        }
-        const result = await this.pool.query(sql, params);
-        return this.success(result.rows.map((row) => this.rowToNode(row, query.includeEmbedding)));
+        return this.run(async () => {
+            let sql = `SELECT * FROM ${this.schema}.graph_nodes WHERE agent_id = $1`;
+            const params = [query.agentId];
+            let paramIndex = 2;
+            if (query.types && query.types.length > 0) {
+                sql += ` AND type = ANY($${paramIndex++})`;
+                params.push(query.types);
+            }
+            if (query.namePattern) {
+                sql += ` AND name ILIKE $${paramIndex++}`;
+                params.push(`%${query.namePattern.replace(/[%_\\]/g, '\\$&')}%`);
+            }
+            if (query.minConfidence !== undefined) {
+                sql += ` AND confidence >= $${paramIndex++}`;
+                params.push(query.minConfidence);
+            }
+            sql += ' ORDER BY access_count DESC, updated_at DESC';
+            if (query.limit) {
+                sql += ` LIMIT $${paramIndex}`;
+                params.push(query.limit);
+            }
+            const result = await this.pool.query(sql, params);
+            return this.success(result.rows.map((row) => this.rowToNode(row, query.includeEmbedding)));
+        });
     }
     async searchNodesSemantic(options) {
-        await this.initialize();
-        if (!options.vector) {
-            return this.failure('searchNodesSemantic requires vector');
-        }
-        const vectorStr = `[${options.vector.join(',')}]`;
-        const limit = options.limit ?? 10;
-        const threshold = options.threshold ?? 0.7;
-        let sql = `
-      SELECT *, 1 - (embedding <=> $1) as score
-      FROM ${this.schema}.graph_nodes
-      WHERE agent_id = $2 AND embedding IS NOT NULL AND 1 - (embedding <=> $1) >= $3
-    `;
-        const params = [vectorStr, options.agentId, threshold];
-        let paramIndex = 4;
-        if (options.entityTypes && options.entityTypes.length > 0) {
-            sql += ` AND type = ANY($${paramIndex++})`;
-            params.push(options.entityTypes);
-        }
-        sql += ` ORDER BY embedding <=> $1 LIMIT $${paramIndex}`;
-        params.push(limit);
-        const result = await this.pool.query(sql, params);
-        return this.success(result.rows.map((row) => ({
-            ...this.rowToNode(row),
-            score: row.score,
-        })));
+        return this.run(async () => {
+            if (!options.vector) {
+                return this.failure('searchNodesSemantic requires vector');
+            }
+            const vectorStr = `[${options.vector.join(',')}]`;
+            const limit = options.limit ?? 10;
+            const threshold = options.threshold ?? 0.7;
+            let sql = `
+        SELECT *, 1 - (embedding <=> $1) as score
+        FROM ${this.schema}.graph_nodes
+        WHERE agent_id = $2 AND embedding IS NOT NULL AND 1 - (embedding <=> $1) >= $3
+      `;
+            const params = [vectorStr, options.agentId, threshold];
+            let paramIndex = 4;
+            if (options.entityTypes && options.entityTypes.length > 0) {
+                sql += ` AND type = ANY($${paramIndex++})`;
+                params.push(options.entityTypes);
+            }
+            sql += ` ORDER BY embedding <=> $1 LIMIT $${paramIndex}`;
+            params.push(limit);
+            const result = await this.pool.query(sql, params);
+            return this.success(result.rows.map((row) => ({
+                ...this.rowToNode(row),
+                score: row.score,
+            })));
+        });
     }
     async addEdge(edge) {
-        await this.initialize();
-        const id = this.generateId('edge');
-        const now = new Date();
-        await this.pool.query(`INSERT INTO ${this.schema}.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 ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $15)`, [
-            id,
-            edge.agentId,
-            edge.sourceNodeId,
-            edge.targetNodeId,
-            edge.type,
-            edge.label ?? null,
-            edge.weight,
-            edge.bidirectional,
-            edge.properties,
-            edge.confidence,
-            edge.source,
-            edge.validFrom ?? null,
-            edge.validUntil ?? null,
-            edge.metadata ?? {},
-            now,
-        ]);
-        return this.success({
-            ...edge,
-            id,
-            createdAt: now,
-            updatedAt: now,
+        return this.run(async () => {
+            const id = this.generateId('edge');
+            const now = new Date();
+            await this.pool.query(`INSERT INTO ${this.schema}.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 ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $15)`, [
+                id,
+                edge.agentId,
+                edge.sourceNodeId,
+                edge.targetNodeId,
+                edge.type,
+                edge.label ?? null,
+                edge.weight,
+                edge.bidirectional,
+                edge.properties,
+                edge.confidence,
+                edge.source,
+                edge.validFrom ?? null,
+                edge.validUntil ?? null,
+                edge.metadata ?? {},
+                now,
+            ]);
+            return this.success({
+                ...edge,
+                id,
+                createdAt: now,
+                updatedAt: now,
+            });
         });
     }
     async getEdge(edgeId) {
-        await this.initialize();
-        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_edges WHERE id = $1`, [
-            edgeId,
-        ]);
-        if (result.rows.length === 0)
-            return this.success(null);
-        return this.success(this.rowToEdge(result.rows[0]));
+        return this.run(async () => {
+            const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_edges WHERE id = $1`, [edgeId]);
+            if (result.rows.length === 0)
+                return this.success(null);
+            return this.success(this.rowToEdge(result.rows[0]));
+        });
     }
     async getEdgesBetween(sourceNodeId, targetNodeId) {
-        await this.initialize();
-        const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_edges
-       WHERE (source_node_id = $1 AND target_node_id = $2)
-          OR (bidirectional = TRUE AND source_node_id = $2 AND target_node_id = $1)`, [sourceNodeId, targetNodeId]);
-        return this.success(result.rows.map((row) => this.rowToEdge(row)));
+        return this.run(async () => {
+            const result = await this.pool.query(`SELECT * FROM ${this.schema}.graph_edges
+         WHERE (source_node_id = $1 AND target_node_id = $2)
+            OR (bidirectional = TRUE AND source_node_id = $2 AND target_node_id = $1)`, [sourceNodeId, targetNodeId]);
+            return this.success(result.rows.map((row) => this.rowToEdge(row)));
+        });
     }
     async updateEdge(edgeId, updates) {
-        await this.initialize();
-        const setClauses = ['updated_at = NOW()'];
-        const params = [];
-        let paramIndex = 1;
-        if (updates.weight !== undefined) {
-            setClauses.push(`weight = $${paramIndex++}`);
-            params.push(updates.weight);
-        }
-        if (updates.label !== undefined) {
-            setClauses.push(`label = $${paramIndex++}`);
-            params.push(updates.label);
-        }
-        if (updates.properties !== undefined) {
-            setClauses.push(`properties = $${paramIndex++}`);
-            params.push(updates.properties);
-        }
-        if (updates.confidence !== undefined) {
-            setClauses.push(`confidence = $${paramIndex++}`);
-            params.push(updates.confidence);
-        }
-        if (updates.validFrom !== undefined) {
-            setClauses.push(`valid_from = $${paramIndex++}`);
-            params.push(updates.validFrom);
-        }
-        if (updates.validUntil !== undefined) {
-            setClauses.push(`valid_until = $${paramIndex++}`);
-            params.push(updates.validUntil);
-        }
-        if (updates.metadata !== undefined) {
-            setClauses.push(`metadata = $${paramIndex++}`);
-            params.push(updates.metadata);
-        }
-        params.push(edgeId);
-        const result = await this.pool.query(`UPDATE ${this.schema}.graph_edges SET ${setClauses.join(', ')} WHERE id = $${paramIndex} RETURNING *`, params);
-        if (result.rows.length === 0) {
-            return this.failure(`Edge not found: ${edgeId}`);
-        }
-        return this.success(this.rowToEdge(result.rows[0]));
+        return this.run(async () => {
+            const setClauses = ['updated_at = NOW()'];
+            const params = [];
+            let paramIndex = 1;
+            if (updates.weight !== undefined) {
+                setClauses.push(`weight = $${paramIndex++}`);
+                params.push(updates.weight);
+            }
+            if (updates.label !== undefined) {
+                setClauses.push(`label = $${paramIndex++}`);
+                params.push(updates.label);
+            }
+            if (updates.properties !== undefined) {
+                setClauses.push(`properties = $${paramIndex++}`);
+                params.push(updates.properties);
+            }
+            if (updates.confidence !== undefined) {
+                setClauses.push(`confidence = $${paramIndex++}`);
+                params.push(updates.confidence);
+            }
+            if (updates.validFrom !== undefined) {
+                setClauses.push(`valid_from = $${paramIndex++}`);
+                params.push(updates.validFrom);
+            }
+            if (updates.validUntil !== undefined) {
+                setClauses.push(`valid_until = $${paramIndex++}`);
+                params.push(updates.validUntil);
+            }
+            if (updates.metadata !== undefined) {
+                setClauses.push(`metadata = $${paramIndex++}`);
+                params.push(updates.metadata);
+            }
+            params.push(edgeId);
+            const result = await this.pool.query(`UPDATE ${this.schema}.graph_edges SET ${setClauses.join(', ')} WHERE id = $${paramIndex} RETURNING *`, params);
+            if (result.rows.length === 0) {
+                return this.failure(`Edge not found: ${edgeId}`);
+            }
+            return this.success(this.rowToEdge(result.rows[0]));
+        });
     }
     async deleteEdge(edgeId) {
-        await this.initialize();
-        await this.pool.query(`DELETE FROM ${this.schema}.graph_edges WHERE id = $1`, [edgeId]);
-        return this.success(undefined);
+        return this.run(async () => {
+            await this.pool.query(`DELETE FROM ${this.schema}.graph_edges WHERE id = $1`, [edgeId]);
+            return this.success(undefined);
+        });
     }
     async queryEdges(query) {
-        await this.initialize();
-        let sql = `SELECT * FROM ${this.schema}.graph_edges WHERE agent_id = $1`;
-        const params = [query.agentId];
-        let paramIndex = 2;
-        if (query.sourceNodeId) {
-            sql += ` AND source_node_id = $${paramIndex++}`;
-            params.push(query.sourceNodeId);
-        }
-        if (query.targetNodeId) {
-            sql += ` AND target_node_id = $${paramIndex++}`;
-            params.push(query.targetNodeId);
-        }
-        if (query.types && query.types.length > 0) {
-            sql += ` AND type = ANY($${paramIndex++})`;
-            params.push(query.types);
-        }
-        if (query.minWeight !== undefined) {
-            sql += ` AND weight >= $${paramIndex++}`;
-            params.push(query.minWeight);
-        }
-        if (query.minConfidence !== undefined) {
-            sql += ` AND confidence >= $${paramIndex++}`;
-            params.push(query.minConfidence);
-        }
-        if (query.bidirectionalOnly) {
-            sql += ' AND bidirectional = TRUE';
-        }
-        sql += ' ORDER BY weight DESC, confidence DESC';
-        if (query.limit) {
-            sql += ` LIMIT $${paramIndex}`;
-            params.push(query.limit);
-        }
-        const result = await this.pool.query(sql, params);
-        return this.success(result.rows.map((row) => this.rowToEdge(row)));
+        return this.run(async () => {
+            let sql = `SELECT * FROM ${this.schema}.graph_edges WHERE agent_id = $1`;
+            const params = [query.agentId];
+            let paramIndex = 2;
+            if (query.sourceNodeId) {
+                sql += ` AND source_node_id = $${paramIndex++}`;
+                params.push(query.sourceNodeId);
+            }
+            if (query.targetNodeId) {
+                sql += ` AND target_node_id = $${paramIndex++}`;
+                params.push(query.targetNodeId);
+            }
+            if (query.types && query.types.length > 0) {
+                sql += ` AND type = ANY($${paramIndex++})`;
+                params.push(query.types);
+            }
+            if (query.minWeight !== undefined) {
+                sql += ` AND weight >= $${paramIndex++}`;
+                params.push(query.minWeight);
+            }
+            if (query.minConfidence !== undefined) {
+                sql += ` AND confidence >= $${paramIndex++}`;
+                params.push(query.minConfidence);
+            }
+            if (query.bidirectionalOnly) {
+                sql += ' AND bidirectional = TRUE';
+            }
+            sql += ' ORDER BY weight DESC, confidence DESC';
+            if (query.limit) {
+                sql += ` LIMIT $${paramIndex}`;
+                params.push(query.limit);
+            }
+            const result = await this.pool.query(sql, params);
+            return this.success(result.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) {
@@ -427,11 +448,9 @@ export class PostgresGraphAdapter {
         }
         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)
@@ -459,196 +478,201 @@ export class PostgresGraphAdapter {
         }
     }
     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.failure(`Node not found: ${startNodeId}`);
+        return this.run(async () => {
+            if (startNodeId === endNodeId) {
+                const node = unwrap(await this.getNode(startNodeId));
+                if (!node) {
+                    return this.failure(`Node not found: ${startNodeId}`);
+                }
+                return this.success({
+                    nodes: [node],
+                    edges: [],
+                    totalWeight: 0,
+                    length: 0,
+                });
             }
-            return this.success({
-                nodes: [nodeResult.data],
-                edges: [],
-                totalWeight: 0,
-                length: 0,
-            });
-        }
-        const result = await this.pool.query(`
-      WITH RECURSIVE path_search AS (
-        SELECT
-          source_node_id as start_node,
-          CASE
-            WHEN source_node_id = $2 THEN target_node_id
-            ELSE source_node_id
-          END as end_node,
-          ARRAY[$2, CASE WHEN source_node_id = $2 THEN target_node_id ELSE source_node_id END] as path,
-          ARRAY[id] as edge_ids,
-          weight as total_weight,
-          1 as depth
-        FROM ${this.schema}.graph_edges
-        WHERE agent_id = $1
-          AND (source_node_id = $2 OR (target_node_id = $2 AND bidirectional = TRUE))
+            const result = await this.pool.query(`
+        WITH RECURSIVE path_search AS (
+          SELECT
+            source_node_id as start_node,
+            CASE
+              WHEN source_node_id = $2 THEN target_node_id
+              ELSE source_node_id
+            END as end_node,
+            ARRAY[$2, CASE WHEN source_node_id = $2 THEN target_node_id ELSE source_node_id END] as path,
+            ARRAY[id] as edge_ids,
+            weight as total_weight,
+            1 as depth
+          FROM ${this.schema}.graph_edges
+          WHERE agent_id = $1
+            AND (source_node_id = $2 OR (target_node_id = $2 AND bidirectional = TRUE))
 
-        UNION ALL
+          UNION ALL
 
-        SELECT
-          ps.start_node,
-          CASE
-            WHEN e.source_node_id = ps.end_node THEN e.target_node_id
-            ELSE e.source_node_id
-          END,
-          ps.path || CASE WHEN e.source_node_id = ps.end_node THEN e.target_node_id ELSE e.source_node_id END,
-          ps.edge_ids || e.id,
-          ps.total_weight + e.weight,
-          ps.depth + 1
-        FROM path_search ps
-        JOIN ${this.schema}.graph_edges e ON (
-          e.source_node_id = ps.end_node
-          OR (e.target_node_id = ps.end_node AND e.bidirectional = TRUE)
+          SELECT
+            ps.start_node,
+            CASE
+              WHEN e.source_node_id = ps.end_node THEN e.target_node_id
+              ELSE e.source_node_id
+            END,
+            ps.path || CASE WHEN e.source_node_id = ps.end_node THEN e.target_node_id ELSE e.source_node_id END,
+            ps.edge_ids || e.id,
+            ps.total_weight + e.weight,
+            ps.depth + 1
+          FROM path_search ps
+          JOIN ${this.schema}.graph_edges e ON (
+            e.source_node_id = ps.end_node
+            OR (e.target_node_id = ps.end_node AND e.bidirectional = TRUE)
+          )
+          WHERE e.agent_id = $1
+            AND NOT (CASE WHEN e.source_node_id = ps.end_node THEN e.target_node_id ELSE e.source_node_id END) = ANY(ps.path)
+            AND ps.depth < $4
         )
-        WHERE e.agent_id = $1
-          AND NOT (CASE WHEN e.source_node_id = ps.end_node THEN e.target_node_id ELSE e.source_node_id END) = ANY(ps.path)
-          AND ps.depth < $4
-      )
-      SELECT path, edge_ids, total_weight
-      FROM path_search
-      WHERE end_node = $3
-      ORDER BY depth, total_weight
-      LIMIT 1
-      `, [agentId, startNodeId, endNodeId, maxDepth]);
-        if (result.rows.length === 0)
-            return this.success(null);
-        const row = result.rows[0];
-        const nodeIds = row.path;
-        const edgeIds = row.edge_ids;
-        const nodes = [];
-        const edges = [];
-        for (const nodeId of nodeIds) {
-            const nodeResult = await this.getNode(nodeId);
-            if (nodeResult.success && nodeResult.data) {
-                nodes.push(nodeResult.data);
+        SELECT path, edge_ids, total_weight
+        FROM path_search
+        WHERE end_node = $3
+        ORDER BY depth, total_weight
+        LIMIT 1
+        `, [agentId, startNodeId, endNodeId, maxDepth]);
+            if (result.rows.length === 0)
+                return this.success(null);
+            const row = result.rows[0];
+            const nodeIds = row.path;
+            const edgeIds = row.edge_ids;
+            const nodes = [];
+            const edges = [];
+            for (const nodeId of nodeIds) {
+                const node = unwrap(await this.getNode(nodeId));
+                if (node)
+                    nodes.push(node);
             }
-        }
-        for (const edgeId of edgeIds) {
-            const edgeResult = await this.getEdge(edgeId);
-            if (edgeResult.success && edgeResult.data) {
-                edges.push(edgeResult.data);
+            for (const edgeId of edgeIds) {
+                const edge = unwrap(await this.getEdge(edgeId));
+                if (edge)
+                    edges.push(edge);
             }
-        }
-        return this.success({
-            nodes,
-            edges,
-            totalWeight: row.total_weight,
-            length: edges.length,
+            return this.success({
+                nodes,
+                edges,
+                totalWeight: row.total_weight,
+                length: edges.length,
+            });
         });
     }
     async getNeighbors(nodeId, direction = 'both') {
-        await this.initialize();
-        let sql;
-        const params = [nodeId];
-        const selectCols = `
-      n.id, n.agent_id, n.type, n.name, n.aliases, n.description,
-      n.properties, 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, e.target_node_id, e.label, e.weight, e.bidirectional,
-      e.properties as edge_properties, e.confidence as edge_confidence,
-      e.source as edge_source, e.valid_from, e.valid_until,
-      e.metadata as edge_metadata, e.created_at as edge_created_at, e.updated_at as edge_updated_at
-    `;
-        if (direction === 'outgoing') {
-            sql = `
-        SELECT ${selectCols}
-        FROM ${this.schema}.graph_edges e
-        JOIN ${this.schema}.graph_nodes n ON n.id = e.target_node_id
-        WHERE e.source_node_id = $1
-        UNION ALL
-        SELECT ${selectCols}
-        FROM ${this.schema}.graph_edges e
-        JOIN ${this.schema}.graph_nodes n ON n.id = e.source_node_id
-        WHERE e.target_node_id = $1 AND e.bidirectional = TRUE
+        return this.run(async () => {
+            let sql;
+            const params = [nodeId];
+            const selectCols = `
+        n.id, n.agent_id, n.type, n.name, n.aliases, n.description,
+        n.properties, 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, e.target_node_id, e.label, e.weight, e.bidirectional,
+        e.properties as edge_properties, e.confidence as edge_confidence,
+        e.source as edge_source, e.valid_from, e.valid_until,
+        e.metadata as edge_metadata, e.created_at as edge_created_at, e.updated_at as edge_updated_at
       `;
-        }
-        else if (direction === 'incoming') {
-            sql = `
-        SELECT ${selectCols}
-        FROM ${this.schema}.graph_edges e
-        JOIN ${this.schema}.graph_nodes n ON n.id = e.source_node_id
-        WHERE e.target_node_id = $1
-        UNION ALL
-        SELECT ${selectCols}
-        FROM ${this.schema}.graph_edges e
-        JOIN ${this.schema}.graph_nodes n ON n.id = e.target_node_id
-        WHERE e.source_node_id = $1 AND e.bidirectional = TRUE
-      `;
-        }
-        else {
-            sql = `
-        SELECT ${selectCols}
-        FROM ${this.schema}.graph_edges e
-        JOIN ${this.schema}.graph_nodes n ON (
-          (e.source_node_id = $1 AND n.id = e.target_node_id) OR
-          (e.target_node_id = $1 AND n.id = e.source_node_id)
-        )
-        WHERE e.source_node_id = $1 OR e.target_node_id = $1
-      `;
-        }
-        const result = await this.pool.query(sql, params);
-        return this.success(result.rows.map((row) => ({
-            node: this.rowToNode(row),
-            edge: this.rowToEdgeFromJoin(row),
-        })));
+            if (direction === 'outgoing') {
+                sql = `
+          SELECT ${selectCols}
+          FROM ${this.schema}.graph_edges e
+          JOIN ${this.schema}.graph_nodes n ON n.id = e.target_node_id
+          WHERE e.source_node_id = $1
+          UNION ALL
+          SELECT ${selectCols}
+          FROM ${this.schema}.graph_edges e
+          JOIN ${this.schema}.graph_nodes n ON n.id = e.source_node_id
+          WHERE e.target_node_id = $1 AND e.bidirectional = TRUE
+        `;
+            }
+            else if (direction === 'incoming') {
+                sql = `
+          SELECT ${selectCols}
+          FROM ${this.schema}.graph_edges e
+          JOIN ${this.schema}.graph_nodes n ON n.id = e.source_node_id
+          WHERE e.target_node_id = $1
+          UNION ALL
+          SELECT ${selectCols}
+          FROM ${this.schema}.graph_edges e
+          JOIN ${this.schema}.graph_nodes n ON n.id = e.target_node_id
+          WHERE e.source_node_id = $1 AND e.bidirectional = TRUE
+        `;
+            }
+            else {
+                sql = `
+          SELECT ${selectCols}
+          FROM ${this.schema}.graph_edges e
+          JOIN ${this.schema}.graph_nodes n ON (
+            (e.source_node_id = $1 AND n.id = e.target_node_id) OR
+            (e.target_node_id = $1 AND n.id = e.source_node_id)
+          )
+          WHERE e.source_node_id = $1 OR e.target_node_id = $1
+        `;
+            }
+            const result = await this.pool.query(sql, params);
+            return this.success(result.rows.map((row) => ({
+                node: this.rowToNode(row),
+                edge: this.rowToEdgeFromJoin(row),
+            })));
+        });
     }
     async mergeNodes(targetNodeId, sourceNodeIds) {
-        await this.initialize();
-        for (const sourceId of sourceNodeIds) {
-            const sourceNode = await this.getNode(sourceId);
-            await this.pool.query(`UPDATE ${this.schema}.graph_edges
-         SET source_node_id = $1 WHERE source_node_id = $2`, [targetNodeId, sourceId]);
-            await this.pool.query(`UPDATE ${this.schema}.graph_edges
-         SET target_node_id = $1 WHERE target_node_id = $2`, [targetNodeId, sourceId]);
-            await this.pool.query(`DELETE FROM ${this.schema}.graph_edges
-         WHERE source_node_id = $1 AND target_node_id = $1`, [targetNodeId]);
-            if (sourceNode.success && sourceNode.data) {
-                await this.pool.query(`UPDATE ${this.schema}.graph_nodes
-           SET aliases = array_cat(aliases, $1::TEXT[])
-           WHERE id = $2`, [[sourceNode.data.name, ...sourceNode.data.aliases], targetNodeId]);
-            }
-            await this.deleteNode(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);
+        return this.run(async () => {
+            for (const sourceId of sourceNodeIds) {
+                const sourceNode = unwrap(await this.getNode(sourceId));
+                await this.pool.query(`UPDATE ${this.schema}.graph_edges
+           SET source_node_id = $1 WHERE source_node_id = $2`, [targetNodeId, sourceId]);
+                await this.pool.query(`UPDATE ${this.schema}.graph_edges
+           SET target_node_id = $1 WHERE target_node_id = $2`, [targetNodeId, sourceId]);
+                await this.pool.query(`DELETE FROM ${this.schema}.graph_edges
+           WHERE source_node_id = $1 AND target_node_id = $1`, [targetNodeId]);
+                if (sourceNode) {
+                    await this.pool.query(`UPDATE ${this.schema}.graph_nodes
+             SET aliases = array_cat(aliases, $1::TEXT[])
+             WHERE id = $2`, [[sourceNode.name, ...sourceNode.aliases], targetNodeId]);
+                }
+                unwrap(await this.deleteNode(sourceId));
+            }
+            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();
-        await this.pool.query(`DELETE FROM ${this.schema}.graph_nodes WHERE agent_id = $1`, [agentId]);
-        return this.success(undefined);
+        return this.run(async () => {
+            await this.pool.query(`DELETE FROM ${this.schema}.graph_nodes WHERE agent_id = $1`, [
+                agentId,
+            ]);
+            return this.success(undefined);
+        });
     }
     async getGraphStats(agentId) {
-        await this.initialize();
-        const nodeCountResult = await this.pool.query(`SELECT COUNT(*) as count FROM ${this.schema}.graph_nodes WHERE agent_id = $1`, [agentId]);
-        const edgeCountResult = await this.pool.query(`SELECT COUNT(*) as count FROM ${this.schema}.graph_edges WHERE agent_id = $1`, [agentId]);
-        const nodesByTypeResult = await this.pool.query(`SELECT type, COUNT(*) as count FROM ${this.schema}.graph_nodes WHERE agent_id = $1 GROUP BY type`, [agentId]);
-        const edgesByTypeResult = await this.pool.query(`SELECT type, COUNT(*) as count FROM ${this.schema}.graph_edges WHERE agent_id = $1 GROUP BY type`, [agentId]);
-        const nodeCount = parseInt(nodeCountResult.rows[0]?.count ?? '0', 10);
-        const edgeCount = parseInt(edgeCountResult.rows[0]?.count ?? '0', 10);
-        const nodesByType = {};
-        for (const row of nodesByTypeResult.rows) {
-            nodesByType[row.type] = parseInt(row.count, 10);
-        }
-        const edgesByType = {};
-        for (const row of edgesByTypeResult.rows) {
-            edgesByType[row.type] = parseInt(row.count, 10);
-        }
-        return this.success({
-            nodeCount,
-            edgeCount,
-            nodesByType,
-            edgesByType,
-            averageEdgesPerNode: nodeCount > 0 ? edgeCount / nodeCount : 0,
-            maxDepth: 0,
+        return this.run(async () => {
+            const nodeCountResult = await this.pool.query(`SELECT COUNT(*) as count FROM ${this.schema}.graph_nodes WHERE agent_id = $1`, [agentId]);
+            const edgeCountResult = await this.pool.query(`SELECT COUNT(*) as count FROM ${this.schema}.graph_edges WHERE agent_id = $1`, [agentId]);
+            const nodesByTypeResult = await this.pool.query(`SELECT type, COUNT(*) as count FROM ${this.schema}.graph_nodes WHERE agent_id = $1 GROUP BY type`, [agentId]);
+            const edgesByTypeResult = await this.pool.query(`SELECT type, COUNT(*) as count FROM ${this.schema}.graph_edges WHERE agent_id = $1 GROUP BY type`, [agentId]);
+            const nodeCount = parseInt(nodeCountResult.rows[0]?.count ?? '0', 10);
+            const edgeCount = parseInt(edgeCountResult.rows[0]?.count ?? '0', 10);
+            const nodesByType = {};
+            for (const row of nodesByTypeResult.rows) {
+                nodesByType[row.type] = parseInt(row.count, 10);
+            }
+            const edgesByType = {};
+            for (const row of edgesByTypeResult.rows) {
+                edgesByType[row.type] = parseInt(row.count, 10);
+            }
+            return this.success({
+                nodeCount,
+                edgeCount,
+                nodesByType,
+                edgesByType,
+                averageEdgesPerNode: nodeCount > 0 ? edgeCount / nodeCount : 0,
+                maxDepth: 0,
+            });
         });
     }
     rowToNode(row, includeEmbedding = false) {