agentic-qe 1.0.5 → 1.2.0

package/dist/learning/ImprovementWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImprovementWorker.js","sourceRoot":"","sources":["../../src/learning/ImprovementWorker.ts"],"names":[],"mappings":"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"}

package/dist/learning/LearningEngine.d.ts

@@ -0,0 +1,144 @@
+/**
+ * LearningEngine - Phase 2 (Milestone 2.2)
+ *
+ * Implements reinforcement learning for agent performance improvement.
+ * Uses Q-learning algorithm to optimize task execution strategies.
+ */
+import { SwarmMemoryManager } from '../core/memory/SwarmMemoryManager';
+import { LearningConfig, TaskState, LearningFeedback, LearningOutcome, LearnedPattern, FailurePattern, StrategyRecommendation } from './types';
+/**
+ * LearningEngine - Reinforcement learning for agents
+ */
+export declare class LearningEngine {
+    private readonly logger;
+    private readonly memoryStore;
+    private readonly agentId;
+    private config;
+    private qTable;
+    private experiences;
+    private patterns;
+    private failurePatterns;
+    private taskCount;
+    constructor(agentId: string, memoryStore: SwarmMemoryManager, config?: Partial<LearningConfig>);
+    /**
+     * Initialize the learning engine
+     */
+    initialize(): Promise<void>;
+    /**
+     * Learn from a task execution
+     */
+    learnFromExecution(task: any, result: any, feedback?: LearningFeedback): Promise<LearningOutcome>;
+    /**
+     * Recommend best strategy for a given state
+     */
+    recommendStrategy(state: TaskState): Promise<StrategyRecommendation>;
+    /**
+     * Get learned patterns
+     */
+    getPatterns(): LearnedPattern[];
+    /**
+     * Get failure patterns
+     */
+    getFailurePatterns(): FailurePattern[];
+    /**
+     * Extract features from state for learning
+     */
+    private extractFeatures;
+    /**
+     * Encode state to string key for Q-table
+     */
+    private encodeState;
+    /**
+     * Encode action to string key
+     */
+    private encodeAction;
+    /**
+     * Extract experience from task execution
+     */
+    private extractExperience;
+    /**
+     * Calculate reward from execution result and feedback
+     */
+    private calculateReward;
+    /**
+     * Update Q-table with new experience (Q-learning algorithm)
+     */
+    private updateQTable;
+    /**
+     * Perform batch update on experiences
+     */
+    private performBatchUpdate;
+    /**
+     * Update learned patterns
+     */
+    private updatePatterns;
+    /**
+     * Detect failure patterns
+     */
+    private detectFailurePattern;
+    /**
+     * Calculate improvement over time
+     */
+    private calculateImprovement;
+    /**
+     * Create learning outcome
+     */
+    private createOutcome;
+    /**
+     * Estimate task complexity
+     */
+    private estimateComplexity;
+    /**
+     * Convert Q-value to confidence score
+     */
+    private valueToConfidence;
+    /**
+     * Decay exploration rate
+     */
+    private decayExploration;
+    /**
+     * Save learning state to memory
+     */
+    private saveState;
+    /**
+     * Load learning state from memory
+     */
+    private loadState;
+    /**
+     * Serialize Q-table for storage
+     */
+    private serializeQTable;
+    /**
+     * Deserialize Q-table from storage
+     */
+    private deserializeQTable;
+    /**
+     * Calculate state size in bytes
+     */
+    private calculateStateSize;
+    /**
+     * Get current performance metrics
+     */
+    private getCurrentPerformance;
+    /**
+     * Emit learning event
+     */
+    private emitLearningEvent;
+    /**
+     * Get current exploration rate
+     */
+    getExplorationRate(): number;
+    /**
+     * Get total experiences
+     */
+    getTotalExperiences(): number;
+    /**
+     * Enable/disable learning
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if learning is enabled
+     */
+    isEnabled(): boolean;
+}
+//# sourceMappingURL=LearningEngine.d.ts.map

package/dist/learning/LearningEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LearningEngine.d.ts","sourceRoot":"","sources":["../../src/learning/LearningEngine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EACL,cAAc,EAEd,SAAS,EAET,gBAAgB,EAChB,eAAe,EACf,cAAc,EAEd,cAAc,EACd,sBAAsB,EAEvB,MAAM,SAAS,CAAC;AAiBjB;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,WAAW,CAAmB;IACtC,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,SAAS,CAAS;gBAGxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,kBAAkB,EAC/B,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM;IAatC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBjC;;OAEG;IACG,kBAAkB,CACtB,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,GAAG,EACX,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,eAAe,CAAC;IAqD3B;;OAEG;IACG,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAoD1E;;OAEG;IACH,WAAW,IAAI,cAAc,EAAE;IAK/B;;OAEG;IACH,kBAAkB,IAAI,cAAc,EAAE;IAKtC;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAyCzB;;OAEG;IACH,OAAO,CAAC,eAAe;IA+BvB;;OAEG;YACW,YAAY;IA4B1B;;OAEG;YACW,kBAAkB;IAgBhC;;OAEG;YACW,cAAc;IAoC5B;;OAEG;YACW,oBAAoB;IAoBlC;;OAEG;YACW,oBAAoB;IAwBlC;;OAEG;IACH,OAAO,CAAC,aAAa;IAiBrB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAc1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;OAEG;YACW,SAAS;IA6BvB;;OAEG;YACW,SAAS;IAmBvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;YACW,qBAAqB;IAiBnC;;OAEG;YACW,iBAAiB;IAiB/B;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;OAEG;IACH,mBAAmB,IAAI,MAAM;IAI7B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC;;OAEG;IACH,SAAS,IAAI,OAAO;CAGrB"}

package/dist/learning/LearningEngine.js

@@ -0,0 +1,531 @@
+"use strict";
+/**
+ * LearningEngine - Phase 2 (Milestone 2.2)
+ *
+ * Implements reinforcement learning for agent performance improvement.
+ * Uses Q-learning algorithm to optimize task execution strategies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningEngine = void 0;
+const uuid_1 = require("uuid");
+const Logger_1 = require("../utils/Logger");
+/**
+ * Default learning configuration
+ */
+const DEFAULT_CONFIG = {
+    enabled: true,
+    learningRate: 0.1,
+    discountFactor: 0.95,
+    explorationRate: 0.3,
+    explorationDecay: 0.995,
+    minExplorationRate: 0.01,
+    maxMemorySize: 100 * 1024 * 1024, // 100MB
+    batchSize: 32,
+    updateFrequency: 10
+};
+/**
+ * LearningEngine - Reinforcement learning for agents
+ */
+class LearningEngine {
+    constructor(agentId, memoryStore, config = {}) {
+        this.logger = Logger_1.Logger.getInstance();
+        this.agentId = agentId;
+        this.memoryStore = memoryStore;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.qTable = new Map();
+        this.experiences = [];
+        this.patterns = new Map();
+        this.failurePatterns = new Map();
+        this.taskCount = 0;
+    }
+    /**
+     * Initialize the learning engine
+     */
+    async initialize() {
+        this.logger.info(`Initializing LearningEngine for agent ${this.agentId}`);
+        // Load previous learning state if exists
+        await this.loadState();
+        // Store config in memory
+        await this.memoryStore.store(`phase2/learning/${this.agentId}/config`, this.config, { partition: 'learning' });
+        this.logger.info('LearningEngine initialized successfully');
+    }
+    /**
+     * Learn from a task execution
+     */
+    async learnFromExecution(task, result, feedback) {
+        if (!this.config.enabled) {
+            return this.createOutcome(false, 0, 0);
+        }
+        // Extract experience from task execution
+        const experience = this.extractExperience(task, result, feedback);
+        this.experiences.push(experience);
+        // Calculate reward
+        const reward = this.calculateReward(result, feedback);
+        experience.reward = reward;
+        // Update Q-table
+        await this.updateQTable(experience);
+        // Update patterns
+        await this.updatePatterns(experience);
+        // Detect failure patterns
+        if (!result.success) {
+            await this.detectFailurePattern(experience);
+        }
+        // Increment task count
+        this.taskCount++;
+        // Periodic model update
+        if (this.taskCount % this.config.updateFrequency === 0) {
+            await this.performBatchUpdate();
+        }
+        // Decay exploration rate
+        this.decayExploration();
+        // Calculate improvement
+        const improvement = await this.calculateImprovement();
+        // Emit learning event
+        await this.emitLearningEvent('training', {
+            experience,
+            reward,
+            improvement
+        });
+        // Save state periodically
+        if (this.taskCount % 50 === 0) {
+            await this.saveState();
+        }
+        return improvement;
+    }
+    /**
+     * Recommend best strategy for a given state
+     */
+    async recommendStrategy(state) {
+        const stateKey = this.encodeState(state);
+        // Get Q-values for all actions in this state
+        const actionValues = this.qTable.get(stateKey) || new Map();
+        if (actionValues.size === 0) {
+            // No learned strategies yet, return default
+            return {
+                strategy: 'default',
+                confidence: 0.5,
+                expectedImprovement: 0,
+                reasoning: 'No learned strategies available yet',
+                alternatives: []
+            };
+        }
+        // Find best action
+        let bestAction = '';
+        let bestValue = -Infinity;
+        const alternatives = [];
+        for (const [action, value] of actionValues.entries()) {
+            if (value > bestValue) {
+                if (bestAction) {
+                    alternatives.push({
+                        strategy: bestAction,
+                        confidence: this.valueToConfidence(bestValue)
+                    });
+                }
+                bestValue = value;
+                bestAction = action;
+            }
+            else {
+                alternatives.push({
+                    strategy: action,
+                    confidence: this.valueToConfidence(value)
+                });
+            }
+        }
+        // Sort alternatives by confidence
+        alternatives.sort((a, b) => b.confidence - a.confidence);
+        return {
+            strategy: bestAction,
+            confidence: this.valueToConfidence(bestValue),
+            expectedImprovement: Math.max(0, bestValue * 100),
+            reasoning: `Learned from ${this.experiences.length} experiences`,
+            alternatives: alternatives.slice(0, 3)
+        };
+    }
+    /**
+     * Get learned patterns
+     */
+    getPatterns() {
+        return Array.from(this.patterns.values())
+            .sort((a, b) => b.confidence - a.confidence);
+    }
+    /**
+     * Get failure patterns
+     */
+    getFailurePatterns() {
+        return Array.from(this.failurePatterns.values())
+            .sort((a, b) => b.frequency - a.frequency);
+    }
+    /**
+     * Extract features from state for learning
+     */
+    extractFeatures(state) {
+        return [
+            state.taskComplexity,
+            state.requiredCapabilities.length / 10, // normalize
+            state.previousAttempts / 5, // normalize
+            state.availableResources,
+            state.timeConstraint ? Math.min(state.timeConstraint / 300000, 1) : 1 // normalize to 5 min
+        ];
+    }
+    /**
+     * Encode state to string key for Q-table
+     */
+    encodeState(state) {
+        const features = this.extractFeatures(state);
+        return features.map(f => Math.round(f * 10) / 10).join(',');
+    }
+    /**
+     * Encode action to string key
+     */
+    encodeAction(action) {
+        return `${action.strategy}:${action.parallelization.toFixed(1)}:${action.retryPolicy}`;
+    }
+    /**
+     * Extract experience from task execution
+     */
+    extractExperience(task, result, feedback) {
+        const state = {
+            taskComplexity: this.estimateComplexity(task),
+            requiredCapabilities: task.requirements?.capabilities || [],
+            contextFeatures: task.context || {},
+            previousAttempts: task.previousAttempts || 0,
+            availableResources: 0.8, // TODO: get from system
+            timeConstraint: task.timeout
+        };
+        const action = {
+            strategy: result.strategy || 'default',
+            toolsUsed: result.toolsUsed || [],
+            parallelization: result.parallelization || 0.5,
+            retryPolicy: result.retryPolicy || 'exponential',
+            resourceAllocation: result.resourceAllocation || 0.5
+        };
+        // Next state (after execution)
+        const nextState = {
+            ...state,
+            previousAttempts: state.previousAttempts + 1,
+            availableResources: state.availableResources * 0.9 // resource consumption
+        };
+        return {
+            taskId: task.id || (0, uuid_1.v4)(),
+            taskType: task.type,
+            state,
+            action,
+            reward: 0, // will be calculated
+            nextState,
+            timestamp: new Date(),
+            agentId: this.agentId
+        };
+    }
+    /**
+     * Calculate reward from execution result and feedback
+     */
+    calculateReward(result, feedback) {
+        let reward = 0;
+        // Success/failure (primary component)
+        reward += result.success ? 1.0 : -1.0;
+        // Execution time (faster is better)
+        if (result.executionTime) {
+            const timeFactor = Math.max(0, 1 - result.executionTime / 30000); // 30 sec baseline
+            reward += timeFactor * 0.5;
+        }
+        // Error rate penalty
+        if (result.errors) {
+            reward -= result.errors.length * 0.1;
+        }
+        // User feedback
+        if (feedback) {
+            reward += (feedback.rating - 0.5) * 2; // -1 to +1
+            reward -= feedback.issues.length * 0.2;
+        }
+        // Coverage/quality bonus (for test generation)
+        if (result.coverage) {
+            reward += (result.coverage - 0.8) * 2; // bonus above 80%
+        }
+        return Math.max(-2, Math.min(2, reward)); // clamp to [-2, 2]
+    }
+    /**
+     * Update Q-table with new experience (Q-learning algorithm)
+     */
+    async updateQTable(experience) {
+        const stateKey = this.encodeState(experience.state);
+        const actionKey = this.encodeAction(experience.action);
+        const nextStateKey = this.encodeState(experience.nextState);
+        // Get or create state-action map
+        if (!this.qTable.has(stateKey)) {
+            this.qTable.set(stateKey, new Map());
+        }
+        const stateActions = this.qTable.get(stateKey);
+        // Get current Q-value
+        const currentQ = stateActions.get(actionKey) || 0;
+        // Get max Q-value for next state
+        const nextStateActions = this.qTable.get(nextStateKey) || new Map();
+        const maxNextQ = nextStateActions.size > 0
+            ? Math.max(...Array.from(nextStateActions.values()))
+            : 0;
+        // Q-learning update: Q(s,a) = Q(s,a) + α * [r + γ * max(Q(s',a')) - Q(s,a)]
+        const newQ = currentQ + this.config.learningRate * (experience.reward + this.config.discountFactor * maxNextQ - currentQ);
+        stateActions.set(actionKey, newQ);
+    }
+    /**
+     * Perform batch update on experiences
+     */
+    async performBatchUpdate() {
+        if (this.experiences.length < this.config.batchSize) {
+            return;
+        }
+        // Sample recent experiences
+        const batch = this.experiences.slice(-this.config.batchSize);
+        // Re-train on batch
+        for (const experience of batch) {
+            await this.updateQTable(experience);
+        }
+        this.logger.info(`Performed batch update on ${batch.length} experiences`);
+    }
+    /**
+     * Update learned patterns
+     */
+    async updatePatterns(experience) {
+        const patternKey = `${experience.taskType}:${experience.action.strategy}`;
+        if (this.patterns.has(patternKey)) {
+            const pattern = this.patterns.get(patternKey);
+            pattern.usageCount++;
+            pattern.lastUsedAt = new Date();
+            // Update success rate
+            if (experience.reward > 0) {
+                pattern.successRate = (pattern.successRate * (pattern.usageCount - 1) + 1) / pattern.usageCount;
+            }
+            else {
+                pattern.successRate = (pattern.successRate * (pattern.usageCount - 1)) / pattern.usageCount;
+            }
+            // Update confidence
+            pattern.confidence = Math.min(0.95, pattern.confidence + 0.01);
+        }
+        else {
+            // Create new pattern
+            const pattern = {
+                id: (0, uuid_1.v4)(),
+                pattern: patternKey,
+                confidence: 0.5,
+                successRate: experience.reward > 0 ? 1.0 : 0.0,
+                usageCount: 1,
+                contexts: [experience.taskType],
+                createdAt: new Date(),
+                lastUsedAt: new Date()
+            };
+            this.patterns.set(patternKey, pattern);
+            // Emit pattern discovered event
+            await this.emitLearningEvent('pattern_discovered', pattern);
+        }
+    }
+    /**
+     * Detect failure patterns
+     */
+    async detectFailurePattern(experience) {
+        const patternKey = `${experience.taskType}:failure`;
+        if (this.failurePatterns.has(patternKey)) {
+            const pattern = this.failurePatterns.get(patternKey);
+            pattern.frequency++;
+            pattern.confidence = Math.min(0.95, pattern.frequency / this.experiences.length);
+        }
+        else {
+            const pattern = {
+                id: (0, uuid_1.v4)(),
+                pattern: patternKey,
+                frequency: 1,
+                contexts: [experience.taskType],
+                confidence: 0.1,
+                identifiedAt: new Date()
+            };
+            this.failurePatterns.set(patternKey, pattern);
+        }
+    }
+    /**
+     * Calculate improvement over time
+     */
+    async calculateImprovement() {
+        if (this.experiences.length < 10) {
+            return this.createOutcome(false, 0, 0);
+        }
+        // Compare recent performance vs baseline
+        const recentExperiences = this.experiences.slice(-20);
+        const baselineExperiences = this.experiences.slice(0, 20);
+        const recentAvgReward = recentExperiences.reduce((sum, e) => sum + e.reward, 0) / recentExperiences.length;
+        const baselineAvgReward = baselineExperiences.reduce((sum, e) => sum + e.reward, 0) / baselineExperiences.length;
+        const improvementRate = baselineAvgReward !== 0
+            ? ((recentAvgReward - baselineAvgReward) / Math.abs(baselineAvgReward)) * 100
+            : 0;
+        return this.createOutcome(improvementRate > 0, baselineAvgReward, recentAvgReward, improvementRate);
+    }
+    /**
+     * Create learning outcome
+     */
+    createOutcome(improved, previous, current, rate = 0) {
+        return {
+            improved,
+            previousPerformance: previous,
+            newPerformance: current,
+            improvementRate: rate,
+            confidence: Math.min(0.95, this.experiences.length / 100),
+            patterns: this.getPatterns().slice(0, 5),
+            timestamp: new Date()
+        };
+    }
+    /**
+     * Estimate task complexity
+     */
+    estimateComplexity(task) {
+        let complexity = 0.5; // baseline
+        if (task.requirements?.capabilities) {
+            complexity += task.requirements.capabilities.length * 0.1;
+        }
+        if (task.previousAttempts) {
+            complexity += task.previousAttempts * 0.1;
+        }
+        return Math.min(1.0, complexity);
+    }
+    /**
+     * Convert Q-value to confidence score
+     */
+    valueToConfidence(value) {
+        return Math.max(0, Math.min(1, (value + 2) / 4)); // map [-2, 2] to [0, 1]
+    }
+    /**
+     * Decay exploration rate
+     */
+    decayExploration() {
+        this.config.explorationRate = Math.max(this.config.minExplorationRate, this.config.explorationRate * this.config.explorationDecay);
+    }
+    /**
+     * Save learning state to memory
+     */
+    async saveState() {
+        const state = {
+            agentId: this.agentId,
+            qTable: this.serializeQTable(),
+            experiences: this.experiences.slice(-1000), // keep last 1000
+            patterns: this.getPatterns(),
+            config: this.config,
+            performance: await this.getCurrentPerformance(),
+            version: '1.0.0',
+            lastUpdated: new Date(),
+            size: this.calculateStateSize()
+        };
+        // Check size limit
+        if (state.size > this.config.maxMemorySize) {
+            this.logger.warn(`Learning state exceeds max size (${state.size} bytes), pruning...`);
+            state.experiences = state.experiences.slice(-500);
+            state.size = this.calculateStateSize();
+        }
+        await this.memoryStore.store(`phase2/learning/${this.agentId}/state`, state, { partition: 'learning' });
+        this.logger.info(`Saved learning state (${state.size} bytes, ${state.experiences.length} experiences)`);
+    }
+    /**
+     * Load learning state from memory
+     */
+    async loadState() {
+        try {
+            const state = await this.memoryStore.retrieve(`phase2/learning/${this.agentId}/state`, { partition: 'learning' });
+            if (state) {
+                this.deserializeQTable(state.qTable);
+                this.experiences = state.experiences;
+                this.patterns = new Map(state.patterns.map(p => [p.pattern, p]));
+                this.taskCount = state.experiences.length;
+                this.logger.info(`Loaded learning state: ${state.experiences.length} experiences`);
+            }
+        }
+        catch (error) {
+            this.logger.warn('No previous learning state found, starting fresh');
+        }
+    }
+    /**
+     * Serialize Q-table for storage
+     */
+    serializeQTable() {
+        const serialized = {};
+        for (const [state, actions] of this.qTable.entries()) {
+            serialized[state] = Object.fromEntries(actions.entries());
+        }
+        return serialized;
+    }
+    /**
+     * Deserialize Q-table from storage
+     */
+    deserializeQTable(data) {
+        this.qTable.clear();
+        for (const [state, actions] of Object.entries(data)) {
+            this.qTable.set(state, new Map(Object.entries(actions)));
+        }
+    }
+    /**
+     * Calculate state size in bytes
+     */
+    calculateStateSize() {
+        return JSON.stringify({
+            qTable: this.serializeQTable(),
+            experiences: this.experiences,
+            patterns: this.getPatterns()
+        }).length;
+    }
+    /**
+     * Get current performance metrics
+     */
+    async getCurrentPerformance() {
+        const recentExperiences = this.experiences.slice(-100);
+        if (recentExperiences.length === 0) {
+            return {
+                avgReward: 0,
+                successRate: 0,
+                totalExperiences: 0
+            };
+        }
+        return {
+            avgReward: recentExperiences.reduce((sum, e) => sum + e.reward, 0) / recentExperiences.length,
+            successRate: recentExperiences.filter(e => e.reward > 0).length / recentExperiences.length,
+            totalExperiences: this.experiences.length
+        };
+    }
+    /**
+     * Emit learning event
+     */
+    async emitLearningEvent(type, data) {
+        const event = {
+            id: (0, uuid_1.v4)(),
+            type: type,
+            agentId: this.agentId,
+            data,
+            timestamp: new Date()
+        };
+        await this.memoryStore.storeEvent({
+            type: `learning:${type}`,
+            payload: event,
+            source: this.agentId,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Get current exploration rate
+     */
+    getExplorationRate() {
+        return this.config.explorationRate;
+    }
+    /**
+     * Get total experiences
+     */
+    getTotalExperiences() {
+        return this.experiences.length;
+    }
+    /**
+     * Enable/disable learning
+     */
+    setEnabled(enabled) {
+        this.config.enabled = enabled;
+    }
+    /**
+     * Check if learning is enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+}
+exports.LearningEngine = LearningEngine;
+//# sourceMappingURL=LearningEngine.js.map