agentic-flow 3.0.0-alpha.2 → 3.1.0

package/dist/packages/agentdb/src/controllers/ReflexionMemory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReflexionMemory.d.ts","sourceRoot":"","sources":["../../../../../../packages/agentdb/src/controllers/ReflexionMemory.ts"],"names":[],"mappings":"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"}

package/dist/packages/agentdb/src/controllers/ReflexionMemory.js

@@ -1,653 +0,0 @@
-/**
- * ReflexionMemory - Episodic Replay Memory System
- *
- * Implements reflexion-style episodic replay for agent self-improvement.
- * Stores self-critiques and outcomes, retrieves relevant past experiences.
- *
- * Based on: "Reflexion: Language Agents with Verbal Reinforcement Learning"
- * https://arxiv.org/abs/2303.11366
- */
-import { NodeIdMapper } from '../utils/NodeIdMapper.js';
-import { cosineSimilarity } from '../utils/vector-math.js';
-export class ReflexionMemory {
-    db;
-    embedder;
-    vectorBackend;
-    learningBackend;
-    graphBackend;
-    constructor(db, embedder, vectorBackend, learningBackend, graphBackend) {
-        this.db = db;
-        this.embedder = embedder;
-        this.vectorBackend = vectorBackend;
-        this.learningBackend = learningBackend;
-        this.graphBackend = graphBackend;
-    }
-    /**
-     * Store a new episode with its critique and outcome
-     */
-    async storeEpisode(episode) {
-        // Use GraphDatabaseAdapter if available (AgentDB v2)
-        if (this.graphBackend && 'storeEpisode' in this.graphBackend) {
-            // GraphDatabaseAdapter has specialized storeEpisode method
-            const graphAdapter = this.graphBackend;
-            // Generate embedding for the task
-            const taskEmbedding = await this.embedder.embed(episode.task);
-            // Create episode node using GraphDatabaseAdapter
-            const nodeId = await graphAdapter.storeEpisode({
-                id: episode.id ? `episode-${episode.id}` : `episode-${Date.now()}-${Math.random()}`,
-                sessionId: episode.sessionId,
-                task: episode.task,
-                reward: episode.reward,
-                success: episode.success,
-                input: episode.input,
-                output: episode.output,
-                critique: episode.critique,
-                createdAt: episode.ts ? episode.ts * 1000 : Date.now(),
-                tokensUsed: episode.tokensUsed,
-                latencyMs: episode.latencyMs
-            }, taskEmbedding);
-            // Return a numeric ID (parse from string ID)
-            const numericId = parseInt(nodeId.split('-').pop() || '0', 36);
-            // Register mapping for later use by CausalMemoryGraph
-            NodeIdMapper.getInstance().register(numericId, nodeId);
-            return numericId;
-        }
-        // Use generic GraphBackend if available
-        if (this.graphBackend) {
-            // Generate embedding for the task
-            const taskEmbedding = await this.embedder.embed(episode.task);
-            // Create episode node ID
-            const nodeId = await this.graphBackend.createNode(['Episode'], {
-                sessionId: episode.sessionId,
-                task: episode.task,
-                input: episode.input || '',
-                output: episode.output || '',
-                critique: episode.critique || '',
-                reward: episode.reward,
-                success: episode.success,
-                latencyMs: episode.latencyMs || 0,
-                tokensUsed: episode.tokensUsed || 0,
-                tags: episode.tags ? JSON.stringify(episode.tags) : '[]',
-                metadata: episode.metadata ? JSON.stringify(episode.metadata) : '{}',
-                createdAt: Date.now()
-            });
-            // Store embedding using vectorBackend if available
-            if (this.vectorBackend && taskEmbedding) {
-                try {
-                    this.vectorBackend.insert(nodeId, taskEmbedding, {
-                        type: 'episode',
-                        sessionId: episode.sessionId
-                    });
-                }
-                catch { /* vectorBackend insert failed — graph node still created */ }
-            }
-            // Return a numeric ID (parse from string ID)
-            const numericId = parseInt(nodeId.split('-').pop() || '0', 36);
-            // Register mapping for later use by CausalMemoryGraph
-            NodeIdMapper.getInstance().register(numericId, nodeId);
-            return numericId;
-        }
-        // Fallback to SQLite (v1 compatibility)
-        const stmt = this.db.prepare(`
-      INSERT INTO episodes (
-        session_id, task, input, output, critique, reward, success,
-        latency_ms, tokens_used, tags, metadata
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        const tags = episode.tags ? JSON.stringify(episode.tags) : null;
-        const metadata = episode.metadata ? JSON.stringify(episode.metadata) : null;
-        const result = stmt.run(episode.sessionId, episode.task, episode.input || null, episode.output || null, episode.critique || null, episode.reward, episode.success ? 1 : 0, episode.latencyMs || null, episode.tokensUsed || null, tags, metadata);
-        const episodeId = result.lastInsertRowid;
-        // Generate and store embedding
-        const text = this.buildEpisodeText(episode);
-        const embedding = await this.embedder.embed(text);
-        // Use vector backend if available (150x faster retrieval)
-        if (this.vectorBackend) {
-            try {
-                this.vectorBackend.insert(episodeId.toString(), embedding);
-            }
-            catch { /* vectorBackend insert failed — SQL fallback used */ }
-        }
-        // Also store in SQL for fallback
-        this.storeEmbedding(episodeId, embedding);
-        // Create graph node for episode if graph backend available
-        if (this.graphBackend) {
-            await this.createEpisodeGraphNode(episodeId, episode, embedding);
-        }
-        // Add training sample if learning backend available
-        if (this.learningBackend && episode.success !== undefined) {
-            this.learningBackend.addSample({
-                embedding,
-                label: episode.success ? 1 : 0,
-                weight: Math.abs(episode.reward),
-                context: {
-                    task: episode.task,
-                    sessionId: episode.sessionId,
-                    latencyMs: episode.latencyMs,
-                    tokensUsed: episode.tokensUsed
-                }
-            });
-        }
-        return episodeId;
-    }
-    /**
-     * Retrieve relevant past episodes for a new task attempt
-     */
-    async retrieveRelevant(query) {
-        const { task, currentState = '', k = 5, minReward, onlyFailures = false, onlySuccesses = false, timeWindowDays } = query;
-        // Generate query embedding
-        const queryText = currentState ? `${task}\n${currentState}` : task;
-        let queryEmbedding = await this.embedder.embed(queryText);
-        // Enhance query with GNN if learning backend available
-        if (this.learningBackend) {
-            queryEmbedding = await this.enhanceQueryWithGNN(queryEmbedding, k);
-        }
-        // Use GraphDatabaseAdapter if available (AgentDB v2)
-        if (this.graphBackend && 'searchSimilarEpisodes' in this.graphBackend) {
-            const graphAdapter = this.graphBackend;
-            // Search using vector similarity
-            const results = await graphAdapter.searchSimilarEpisodes(queryEmbedding, k * 3);
-            // Apply filters
-            const filtered = results.filter((ep) => {
-                if (minReward !== undefined && ep.reward < minReward)
-                    return false;
-                if (onlyFailures && ep.success)
-                    return false;
-                if (onlySuccesses && !ep.success)
-                    return false;
-                if (timeWindowDays && ep.createdAt < (Date.now() - timeWindowDays * 86400000))
-                    return false;
-                return true;
-            });
-            // Convert to EpisodeWithEmbedding format
-            const episodes = filtered.slice(0, k).map((ep) => ({
-                id: parseInt(ep.id.split('-').pop() || '0', 36),
-                sessionId: ep.sessionId,
-                task: ep.task,
-                input: ep.input,
-                output: ep.output,
-                critique: ep.critique,
-                reward: ep.reward,
-                success: ep.success,
-                latencyMs: ep.latencyMs,
-                tokensUsed: ep.tokensUsed,
-                ts: Math.floor(ep.createdAt / 1000)
-            }));
-            return episodes;
-        }
-        // Use generic GraphBackend if available
-        if (this.graphBackend && 'execute' in this.graphBackend) {
-            // Build Cypher query with filters
-            let cypherQuery = 'MATCH (e:Episode) WHERE 1=1';
-            if (minReward !== undefined) {
-                cypherQuery += ` AND e.reward >= ${minReward}`;
-            }
-            if (onlyFailures) {
-                cypherQuery += ` AND e.success = false`;
-            }
-            if (onlySuccesses) {
-                cypherQuery += ` AND e.success = true`;
-            }
-            if (timeWindowDays) {
-                const cutoff = Date.now() - timeWindowDays * 86400000;
-                cypherQuery += ` AND e.createdAt >= ${cutoff}`;
-            }
-            cypherQuery += ` RETURN e LIMIT ${k * 3}`;
-            const result = await this.graphBackend.execute(cypherQuery);
-            // Convert to EpisodeWithEmbedding format
-            const episodes = result.rows.map((row) => {
-                const node = row.e;
-                return {
-                    id: parseInt(node.id.split('-').pop() || '0', 36),
-                    sessionId: node.properties.sessionId,
-                    task: node.properties.task,
-                    input: node.properties.input,
-                    output: node.properties.output,
-                    critique: node.properties.critique,
-                    reward: typeof node.properties.reward === 'string' ? parseFloat(node.properties.reward) : node.properties.reward,
-                    success: typeof node.properties.success === 'string' ? node.properties.success === 'true' : node.properties.success,
-                    latencyMs: node.properties.latencyMs,
-                    tokensUsed: node.properties.tokensUsed,
-                    tags: node.properties.tags ? JSON.parse(node.properties.tags) : [],
-                    metadata: node.properties.metadata ? JSON.parse(node.properties.metadata) : {},
-                    ts: Math.floor(node.properties.createdAt / 1000)
-                };
-            });
-            return episodes.slice(0, k);
-        }
-        // Use optimized vector backend if available (150x faster)
-        if (this.vectorBackend) {
-            try {
-                // Get candidates from vector backend
-                const searchResults = this.vectorBackend.search(queryEmbedding, k * 3, {
-                    threshold: 0.0
-                });
-                // Fetch full episode data from DB
-                const episodeIds = searchResults.map(r => parseInt(r.id));
-                if (episodeIds.length === 0) {
-                    return [];
-                }
-                const placeholders = episodeIds.map(() => '?').join(',');
-                const stmt = this.db.prepare(`
-        SELECT * FROM episodes
-        WHERE id IN (${placeholders})
-      `);
-                const rows = stmt.all(...episodeIds);
-                const episodeMap = new Map(rows.map(r => [r.id.toString(), r]));
-                // Map results back with similarity scores and apply filters
-                const episodes = [];
-                for (const result of searchResults) {
-                    const row = episodeMap.get(result.id);
-                    if (!row)
-                        continue;
-                    // Apply additional filters
-                    if (minReward !== undefined && row.reward < minReward)
-                        continue;
-                    if (onlyFailures && row.success === 1)
-                        continue;
-                    if (onlySuccesses && row.success === 0)
-                        continue;
-                    if (timeWindowDays && row.ts < (Date.now() / 1000 - timeWindowDays * 86400))
-                        continue;
-                    episodes.push({
-                        id: row.id,
-                        ts: row.ts,
-                        sessionId: row.session_id,
-                        task: row.task,
-                        input: row.input,
-                        output: row.output,
-                        critique: row.critique,
-                        reward: row.reward,
-                        success: row.success === 1,
-                        latencyMs: row.latency_ms,
-                        tokensUsed: row.tokens_used,
-                        tags: row.tags ? JSON.parse(row.tags) : undefined,
-                        metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-                        similarity: result.similarity
-                    });
-                    if (episodes.length >= k)
-                        break;
-                }
-                return episodes;
-            }
-            catch { /* vectorBackend search failed — fall through to SQL */ }
-        }
-        // Fallback to SQL-based similarity search
-        const filters = [];
-        const params = [];
-        if (minReward !== undefined) {
-            filters.push('e.reward >= ?');
-            params.push(minReward);
-        }
-        if (onlyFailures) {
-            filters.push('e.success = 0');
-        }
-        if (onlySuccesses) {
-            filters.push('e.success = 1');
-        }
-        if (timeWindowDays) {
-            filters.push('e.ts > strftime("%s", "now") - ?');
-            params.push(timeWindowDays * 86400);
-        }
-        const whereClause = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : '';
-        const stmt = this.db.prepare(`
-      SELECT
-        e.*,
-        ee.embedding
-      FROM episodes e
-      JOIN episode_embeddings ee ON e.id = ee.episode_id
-      ${whereClause}
-      ORDER BY e.reward DESC
-    `);
-        const rows = stmt.all(...params);
-        // Calculate similarities manually
-        const episodes = rows.map(row => {
-            const embedding = this.deserializeEmbedding(row.embedding);
-            const similarity = cosineSimilarity(queryEmbedding, embedding);
-            return {
-                id: row.id,
-                ts: row.ts,
-                sessionId: row.session_id,
-                task: row.task,
-                input: row.input,
-                output: row.output,
-                critique: row.critique,
-                reward: row.reward,
-                success: row.success === 1,
-                latencyMs: row.latency_ms,
-                tokensUsed: row.tokens_used,
-                tags: row.tags ? JSON.parse(row.tags) : undefined,
-                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-                embedding,
-                similarity
-            };
-        });
-        // Sort by similarity and return top-k
-        episodes.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
-        return episodes.slice(0, k);
-    }
-    /**
-     * Get statistics for a task
-     */
-    getTaskStats(task, timeWindowDays) {
-        const windowFilter = timeWindowDays
-            ? `AND ts > strftime('%s', 'now') - ${timeWindowDays * 86400}`
-            : '';
-        const stmt = this.db.prepare(`
-      SELECT
-        COUNT(*) as total,
-        AVG(CASE WHEN success = 1 THEN 1.0 ELSE 0.0 END) as success_rate,
-        AVG(reward) as avg_reward,
-        AVG(latency_ms) as avg_latency
-      FROM episodes
-      WHERE task = ? ${windowFilter}
-    `);
-        const stats = stmt.get(task);
-        // Calculate improvement trend (recent vs older)
-        const trendStmt = this.db.prepare(`
-      SELECT
-        AVG(CASE
-          WHEN ts > strftime('%s', 'now') - ${7 * 86400} THEN reward
-        END) as recent_reward,
-        AVG(CASE
-          WHEN ts <= strftime('%s', 'now') - ${7 * 86400} THEN reward
-        END) as older_reward
-      FROM episodes
-      WHERE task = ? ${windowFilter}
-    `);
-        const trend = trendStmt.get(task);
-        const improvementTrend = trend.recent_reward && trend.older_reward
-            ? (trend.recent_reward - trend.older_reward) / trend.older_reward
-            : 0;
-        return {
-            totalAttempts: stats.total || 0,
-            successRate: stats.success_rate || 0,
-            avgReward: stats.avg_reward || 0,
-            avgLatency: stats.avg_latency || 0,
-            improvementTrend
-        };
-    }
-    /**
-     * Build critique summary from similar failed episodes
-     */
-    async getCritiqueSummary(query) {
-        const failures = await this.retrieveRelevant({
-            ...query,
-            onlyFailures: true,
-            k: 3
-        });
-        if (failures.length === 0) {
-            return 'No prior failures found for this task.';
-        }
-        const critiques = failures
-            .filter(ep => ep.critique)
-            .map((ep, i) => `${i + 1}. ${ep.critique} (reward: ${ep.reward.toFixed(2)})`)
-            .join('\n');
-        return `Prior failures and lessons learned:\n${critiques}`;
-    }
-    /**
-     * Get successful strategies for a task
-     */
-    async getSuccessStrategies(query) {
-        const successes = await this.retrieveRelevant({
-            ...query,
-            onlySuccesses: true,
-            minReward: 0.7,
-            k: 3
-        });
-        if (successes.length === 0) {
-            return 'No successful strategies found for this task.';
-        }
-        const strategies = successes
-            .map((ep, i) => {
-            const approach = ep.output?.substring(0, 200) || 'No output recorded';
-            return `${i + 1}. Approach (reward ${ep.reward.toFixed(2)}): ${approach}...`;
-        })
-            .join('\n');
-        return `Successful strategies:\n${strategies}`;
-    }
-    /**
-     * Get recent episodes for a session
-     */
-    async getRecentEpisodes(sessionId, limit = 10) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM episodes
-      WHERE session_id = ?
-      ORDER BY ts DESC
-      LIMIT ?
-    `);
-        const rows = stmt.all(sessionId, limit);
-        return rows.map(row => ({
-            id: row.id,
-            ts: row.ts,
-            sessionId: row.session_id,
-            task: row.task,
-            input: row.input,
-            output: row.output,
-            critique: row.critique,
-            reward: row.reward,
-            success: row.success === 1,
-            latencyMs: row.latency_ms,
-            tokensUsed: row.tokens_used,
-            tags: row.tags ? JSON.parse(row.tags) : undefined,
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
-        }));
-    }
-    /**
-     * Prune low-quality episodes based on TTL and quality threshold
-     */
-    pruneEpisodes(config) {
-        const { minReward = 0.3, maxAgeDays = 30, keepMinPerTask = 5 } = config;
-        // Keep high-reward episodes and minimum per task
-        const stmt = this.db.prepare(`
-      DELETE FROM episodes
-      WHERE id IN (
-        SELECT id FROM (
-          SELECT
-            id,
-            reward,
-            ts,
-            ROW_NUMBER() OVER (PARTITION BY task ORDER BY reward DESC) as rank
-          FROM episodes
-          WHERE reward < ?
-            AND ts < strftime('%s', 'now') - ?
-        ) WHERE rank > ?
-      )
-    `);
-        const result = stmt.run(minReward, maxAgeDays * 86400, keepMinPerTask);
-        return result.changes;
-    }
-    // ========================================================================
-    // Private Helper Methods
-    // ========================================================================
-    buildEpisodeText(episode) {
-        const parts = [episode.task];
-        if (episode.critique)
-            parts.push(episode.critique);
-        if (episode.output)
-            parts.push(episode.output);
-        return parts.join('\n');
-    }
-    storeEmbedding(episodeId, embedding) {
-        const stmt = this.db.prepare(`
-      INSERT INTO episode_embeddings (episode_id, embedding)
-      VALUES (?, ?)
-    `);
-        stmt.run(episodeId, this.serializeEmbedding(embedding));
-    }
-    serializeEmbedding(embedding) {
-        // Handle empty/null embeddings
-        if (!embedding || !embedding.buffer) {
-            return Buffer.alloc(0);
-        }
-        return Buffer.from(embedding.buffer);
-    }
-    deserializeEmbedding(buffer) {
-        return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.length / 4);
-    }
-    // ========================================================================
-    // GNN and Graph Integration Methods
-    // ========================================================================
-    /**
-     * Create graph node for episode with relationships
-     */
-    async createEpisodeGraphNode(episodeId, episode, embedding) {
-        if (!this.graphBackend)
-            return;
-        // Create episode node
-        const nodeId = await this.graphBackend.createNode(['Episode', episode.success ? 'Success' : 'Failure'], {
-            episodeId,
-            sessionId: episode.sessionId,
-            task: episode.task,
-            reward: episode.reward,
-            success: episode.success,
-            timestamp: episode.ts || Date.now(),
-            latencyMs: episode.latencyMs,
-            tokensUsed: episode.tokensUsed
-        });
-        // Find similar episodes using graph vector search
-        const similarEpisodes = await this.graphBackend.vectorSearch(embedding, 5, nodeId);
-        // Create similarity relationships to similar episodes
-        for (const similar of similarEpisodes) {
-            if (similar.id !== nodeId && similar.properties.episodeId !== episodeId) {
-                await this.graphBackend.createRelationship(nodeId, similar.id, 'SIMILAR_TO', {
-                    similarity: cosineSimilarity(embedding, similar.embedding || new Float32Array()),
-                    createdAt: Date.now()
-                });
-            }
-        }
-        // Create session relationship
-        const sessionNodes = await this.graphBackend.execute('MATCH (s:Session {sessionId: $sessionId}) RETURN s', { sessionId: episode.sessionId });
-        let sessionNodeId;
-        if (sessionNodes.rows.length === 0) {
-            // Create session node if doesn't exist
-            sessionNodeId = await this.graphBackend.createNode(['Session'], {
-                sessionId: episode.sessionId,
-                startTime: episode.ts || Date.now()
-            });
-        }
-        else {
-            sessionNodeId = sessionNodes.rows[0].s.id;
-        }
-        await this.graphBackend.createRelationship(nodeId, sessionNodeId, 'BELONGS_TO_SESSION', { timestamp: episode.ts || Date.now() });
-        // If episode has critique, create causal relationship to previous failures
-        if (episode.critique && !episode.success) {
-            const previousFailures = await this.graphBackend.execute(`MATCH (e:Episode:Failure {sessionId: $sessionId})
-         WHERE e.timestamp < $timestamp
-         RETURN e
-         ORDER BY e.timestamp DESC
-         LIMIT 3`, { sessionId: episode.sessionId, timestamp: episode.ts || Date.now() });
-            for (const prevFailure of previousFailures.rows) {
-                await this.graphBackend.createRelationship(nodeId, prevFailure.e.id, 'LEARNED_FROM', {
-                    critique: episode.critique,
-                    improvementAttempt: true
-                });
-            }
-        }
-    }
-    /**
-     * Enhance query embedding using GNN attention mechanism
-     */
-    async enhanceQueryWithGNN(queryEmbedding, k) {
-        if (!this.learningBackend || !this.vectorBackend) {
-            return queryEmbedding;
-        }
-        try {
-            // Get initial neighbors
-            const initialResults = this.vectorBackend.search(queryEmbedding, k * 2, {
-                threshold: 0.0
-            });
-            if (initialResults.length === 0) {
-                return queryEmbedding;
-            }
-            // Fetch neighbor embeddings
-            const neighborEmbeddings = [];
-            const weights = [];
-            const episodeIds = initialResults.map(r => r.id);
-            const placeholders = episodeIds.map(() => '?').join(',');
-            const episodes = this.db.prepare(`
-        SELECT ee.embedding, e.reward
-        FROM episode_embeddings ee
-        JOIN episodes e ON e.id = ee.episode_id
-        WHERE ee.episode_id IN (${placeholders})
-      `).all(...episodeIds);
-            for (const ep of episodes) {
-                const embedding = this.deserializeEmbedding(ep.embedding);
-                neighborEmbeddings.push(embedding);
-                // Use reward as weight (higher reward = more important)
-                weights.push(Math.max(0.1, ep.reward));
-            }
-            // Enhance query using GNN
-            const enhanced = this.learningBackend.enhance(queryEmbedding, neighborEmbeddings, weights);
-            return enhanced;
-        }
-        catch (error) {
-            console.warn('[ReflexionMemory] GNN enhancement failed:', error);
-            return queryEmbedding;
-        }
-    }
-    /**
-     * Get graph-based episode relationships
-     */
-    async getEpisodeRelationships(episodeId) {
-        if (!this.graphBackend) {
-            return { similar: [], session: '', learnedFrom: [] };
-        }
-        const result = await this.graphBackend.execute(`MATCH (e:Episode {episodeId: $episodeId})
-       OPTIONAL MATCH (e)-[:SIMILAR_TO]->(similar:Episode)
-       OPTIONAL MATCH (e)-[:BELONGS_TO_SESSION]->(s:Session)
-       OPTIONAL MATCH (e)-[:LEARNED_FROM]->(learned:Episode)
-       RETURN e, collect(DISTINCT similar.episodeId) as similar,
-              s.sessionId as session,
-              collect(DISTINCT learned.episodeId) as learnedFrom`, { episodeId });
-        if (result.rows.length === 0) {
-            return { similar: [], session: '', learnedFrom: [] };
-        }
-        const row = result.rows[0];
-        return {
-            similar: (row.similar || []).filter((id) => id != null),
-            session: row.session || '',
-            learnedFrom: (row.learnedFrom || []).filter((id) => id != null)
-        };
-    }
-    /**
-     * Train GNN model on accumulated samples
-     */
-    async trainGNN(options) {
-        if (!this.learningBackend) {
-            console.warn('[ReflexionMemory] No learning backend available for training');
-            return;
-        }
-        const stats = this.learningBackend.getStats();
-        if (stats.samplesCollected < 10) {
-            console.warn('[ReflexionMemory] Not enough samples for training (need at least 10)');
-            return;
-        }
-        const result = await this.learningBackend.train(options);
-        console.log('[ReflexionMemory] GNN training complete:', {
-            epochs: result.epochs,
-            finalLoss: result.finalLoss.toFixed(4),
-            improvement: `${(result.improvement * 100).toFixed(1)}%`,
-            duration: `${result.duration}ms`
-        });
-    }
-    /**
-     * Get learning backend statistics
-     */
-    getLearningStats() {
-        if (!this.learningBackend) {
-            return null;
-        }
-        return this.learningBackend.getStats();
-    }
-    /**
-     * Get graph backend statistics
-     */
-    getGraphStats() {
-        if (!this.graphBackend) {
-            return null;
-        }
-        return this.graphBackend.getStats();
-    }
-}
-//# sourceMappingURL=ReflexionMemory.js.map