agentdb 1.0.12 → 1.1.0

package/dist/mcp/learning/core/session-manager.mjs

@@ -1,197 +0,0 @@
-/**
- * SessionManager - Manages learning session lifecycle and state
- */
-export class SessionManager {
-    constructor(db) {
-        this.activeSessions = new Map();
-        this.db = db;
-    }
-    /**
-     * Create a new learning session
-     */
-    async createSession(userId, sessionType, plugin, config = {}) {
-        const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        const session = {
-            sessionId,
-            userId,
-            sessionType,
-            plugin,
-            status: 'active',
-            startTime: Date.now(),
-            experienceCount: 0,
-            config,
-        };
-        this.activeSessions.set(sessionId, session);
-        await this.persistSession(session);
-        return session;
-    }
-    /**
-     * Get active session by ID
-     */
-    getSession(sessionId) {
-        return this.activeSessions.get(sessionId);
-    }
-    /**
-     * Get all active sessions for a user
-     */
-    getUserSessions(userId) {
-        return Array.from(this.activeSessions.values()).filter((session) => session.userId === userId && session.status === 'active');
-    }
-    /**
-     * Pause a learning session
-     */
-    async pauseSession(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        session.status = 'paused';
-        await this.persistSession(session);
-    }
-    /**
-     * Resume a paused session
-     */
-    async resumeSession(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        if (session.status !== 'paused') {
-            throw new Error(`Session ${sessionId} is not paused`);
-        }
-        session.status = 'active';
-        await this.persistSession(session);
-    }
-    /**
-     * End a learning session
-     */
-    async endSession(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        session.status = 'ended';
-        session.endTime = Date.now();
-        await this.persistSession(session);
-        this.activeSessions.delete(sessionId);
-        return session;
-    }
-    /**
-     * Update session experience count
-     */
-    incrementExperienceCount(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (session) {
-            session.experienceCount++;
-        }
-    }
-    /**
-     * Update session policy
-     */
-    async updateSessionPolicy(sessionId, policy) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        session.currentPolicy = policy;
-        await this.persistSession(session);
-    }
-    /**
-     * Get session metrics
-     */
-    getSessionMetrics(sessionId) {
-        const session = this.activeSessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        const endTime = session.endTime || Date.now();
-        const duration = endTime - session.startTime;
-        return {
-            duration,
-            experienceCount: session.experienceCount,
-            status: session.status,
-        };
-    }
-    /**
-     * Persist session to vector database
-     */
-    async persistSession(session) {
-        // Create a simple embedding for session metadata
-        const sessionText = JSON.stringify({
-            userId: session.userId,
-            sessionType: session.sessionType,
-            plugin: session.plugin,
-        });
-        const embedding = new Float32Array(768);
-        for (let i = 0; i < sessionText.length; i++) {
-            const index = sessionText.charCodeAt(i) % 768;
-            embedding[index] += 1;
-        }
-        // Normalize
-        const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
-        if (magnitude > 0) {
-            for (let i = 0; i < embedding.length; i++) {
-                embedding[i] /= magnitude;
-            }
-        }
-        await this.db.insert({
-            embedding: Array.from(embedding),
-            metadata: {
-                type: 'learning_session',
-                sessionId: session.sessionId,
-                userId: session.userId,
-                sessionType: session.sessionType,
-                plugin: session.plugin,
-                status: session.status,
-                startTime: session.startTime,
-                endTime: session.endTime,
-                experienceCount: session.experienceCount,
-                config: session.config,
-                currentPolicy: session.currentPolicy,
-            },
-        });
-    }
-    /**
-     * Restore sessions from database
-     */
-    async restoreSessions(userId) {
-        const filter = { type: 'learning_session', status: 'active' };
-        if (userId) {
-            filter.userId = userId;
-        }
-        const results = await this.db.search(Array(768).fill(0), 1000);
-        const sessions = [];
-        for (const result of results) {
-            const session = {
-                sessionId: result.metadata.sessionId,
-                userId: result.metadata.userId,
-                sessionType: result.metadata.sessionType,
-                plugin: result.metadata.plugin,
-                status: result.metadata.status,
-                startTime: result.metadata.startTime,
-                endTime: result.metadata.endTime,
-                experienceCount: result.metadata.experienceCount,
-                config: result.metadata.config,
-                currentPolicy: result.metadata.currentPolicy,
-            };
-            this.activeSessions.set(session.sessionId, session);
-            sessions.push(session);
-        }
-        return sessions;
-    }
-    /**
-     * Cleanup old sessions
-     */
-    async cleanupOldSessions(maxAge = 7 * 24 * 60 * 60 * 1000) {
-        const cutoff = Date.now() - maxAge;
-        let cleaned = 0;
-        for (const [sessionId, session] of this.activeSessions.entries()) {
-            const endTime = session.endTime || Date.now();
-            if (endTime < cutoff && session.status === 'ended') {
-                this.activeSessions.delete(sessionId);
-                cleaned++;
-            }
-        }
-        return cleaned;
-    }
-}

package/dist/mcp/learning/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * MCP Learning Integration - Main Entry Point
- *
- * Provides reinforcement learning capabilities for MCP tools including:
- * - Experience recording and replay
- * - Multi-dimensional reward calculation
- * - Policy optimization (Q-learning)
- * - Session management
- * - Transfer learning between tasks
- */
-export { LearningManager } from './core/learning-manager.js';
-export { ExperienceRecorder } from './core/experience-recorder.js';
-export { RewardEstimator } from './core/reward-estimator.js';
-export { SessionManager } from './core/session-manager.js';
-export { PolicyOptimizer } from './core/policy-optimizer.js';
-export { ExperienceBuffer } from './core/experience-buffer.js';
-export { MCPLearningTools } from './tools/mcp-learning-tools.js';
-export type { ExecutionContext, State, Action, Experience, Outcome, Reward, ActionPrediction, TrainingOptions, TrainingMetrics, LearningSession, FeedbackInput, LearningMetrics, TransferMetrics, } from './types/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/mcp/learning/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mcp/learning/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAG/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGjE,YAAY,EACV,gBAAgB,EAChB,KAAK,EACL,MAAM,EACN,UAAU,EACV,OAAO,EACP,MAAM,EACN,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,eAAe,EACf,aAAa,EACb,eAAe,EACf,eAAe,GAChB,MAAM,kBAAkB,CAAC"}

package/dist/mcp/learning/index.js

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * MCP Learning Integration - Main Entry Point
- *
- * Provides reinforcement learning capabilities for MCP tools including:
- * - Experience recording and replay
- * - Multi-dimensional reward calculation
- * - Policy optimization (Q-learning)
- * - Session management
- * - Transfer learning between tasks
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPLearningTools = exports.ExperienceBuffer = exports.PolicyOptimizer = exports.SessionManager = exports.RewardEstimator = exports.ExperienceRecorder = exports.LearningManager = void 0;
-// Core classes
-var learning_manager_js_1 = require("./core/learning-manager.js");
-Object.defineProperty(exports, "LearningManager", { enumerable: true, get: function () { return learning_manager_js_1.LearningManager; } });
-var experience_recorder_js_1 = require("./core/experience-recorder.js");
-Object.defineProperty(exports, "ExperienceRecorder", { enumerable: true, get: function () { return experience_recorder_js_1.ExperienceRecorder; } });
-var reward_estimator_js_1 = require("./core/reward-estimator.js");
-Object.defineProperty(exports, "RewardEstimator", { enumerable: true, get: function () { return reward_estimator_js_1.RewardEstimator; } });
-var session_manager_js_1 = require("./core/session-manager.js");
-Object.defineProperty(exports, "SessionManager", { enumerable: true, get: function () { return session_manager_js_1.SessionManager; } });
-var policy_optimizer_js_1 = require("./core/policy-optimizer.js");
-Object.defineProperty(exports, "PolicyOptimizer", { enumerable: true, get: function () { return policy_optimizer_js_1.PolicyOptimizer; } });
-var experience_buffer_js_1 = require("./core/experience-buffer.js");
-Object.defineProperty(exports, "ExperienceBuffer", { enumerable: true, get: function () { return experience_buffer_js_1.ExperienceBuffer; } });
-// MCP tools
-var mcp_learning_tools_js_1 = require("./tools/mcp-learning-tools.js");
-Object.defineProperty(exports, "MCPLearningTools", { enumerable: true, get: function () { return mcp_learning_tools_js_1.MCPLearningTools; } });
-//# sourceMappingURL=index.js.map

package/dist/mcp/learning/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mcp/learning/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAEH,eAAe;AACf,kEAA6D;AAApD,sHAAA,eAAe,OAAA;AACxB,wEAAmE;AAA1D,4HAAA,kBAAkB,OAAA;AAC3B,kEAA6D;AAApD,sHAAA,eAAe,OAAA;AACxB,gEAA2D;AAAlD,oHAAA,cAAc,OAAA;AACvB,kEAA6D;AAApD,sHAAA,eAAe,OAAA;AACxB,oEAA+D;AAAtD,wHAAA,gBAAgB,OAAA;AAEzB,YAAY;AACZ,uEAAiE;AAAxD,yHAAA,gBAAgB,OAAA"}

package/dist/mcp/learning/index.mjs

@@ -1,19 +0,0 @@
-/**
- * MCP Learning Integration - Main Entry Point
- *
- * Provides reinforcement learning capabilities for MCP tools including:
- * - Experience recording and replay
- * - Multi-dimensional reward calculation
- * - Policy optimization (Q-learning)
- * - Session management
- * - Transfer learning between tasks
- */
-// Core classes
-export { LearningManager } from './core/learning-manager.mjs';
-export { ExperienceRecorder } from './core/experience-recorder.mjs';
-export { RewardEstimator } from './core/reward-estimator.mjs';
-export { SessionManager } from './core/session-manager.mjs';
-export { PolicyOptimizer } from './core/policy-optimizer.mjs';
-export { ExperienceBuffer } from './core/experience-buffer.mjs';
-// MCP tools
-export { MCPLearningTools } from './tools/mcp-learning-tools.mjs';

package/dist/mcp/learning/tools/mcp-learning-tools.d.ts

@@ -1,369 +0,0 @@
-/**
- * MCP Learning Tools - Tool definitions for MCP server integration
- */
-import type { LearningManager } from '../core/learning-manager.js';
-export declare class MCPLearningTools {
-    private learningManager;
-    constructor(learningManager: LearningManager);
-    /**
-     * Get all tool definitions for MCP server
-     */
-    getToolDefinitions(): {
-        learning_start_session: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    userId: {
-                        type: string;
-                        description: string;
-                    };
-                    sessionType: {
-                        type: string;
-                        enum: string[];
-                        description: string;
-                    };
-                    plugin: {
-                        type: string;
-                        default: string;
-                        description: string;
-                    };
-                    config: {
-                        type: string;
-                        description: string;
-                        properties: {
-                            learningRate: {
-                                type: string;
-                                default: number;
-                            };
-                            discountFactor: {
-                                type: string;
-                                default: number;
-                            };
-                            bufferSize: {
-                                type: string;
-                                default: number;
-                            };
-                        };
-                    };
-                };
-                required: string[];
-            };
-        };
-        learning_end_session: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sessionId: {
-                        type: string;
-                        description: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-        learning_predict: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    currentState: {
-                        type: string;
-                        description: string;
-                        properties: {
-                            taskDescription: {
-                                type: string;
-                            };
-                            availableTools: {
-                                type: string;
-                                items: {
-                                    type: string;
-                                };
-                            };
-                            previousActions: {
-                                type: string;
-                                items: {
-                                    type: string;
-                                };
-                            };
-                        };
-                        required: string[];
-                    };
-                    availableTools: {
-                        type: string;
-                        items: {
-                            type: string;
-                        };
-                        description: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-        learning_feedback: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    actionId: {
-                        type: string;
-                        description: string;
-                    };
-                    feedback: {
-                        type: string;
-                        properties: {
-                            success: {
-                                type: string;
-                            };
-                            rating: {
-                                type: string;
-                                minimum: number;
-                                maximum: number;
-                                description: string;
-                            };
-                            comments: {
-                                type: string;
-                            };
-                            dimensions: {
-                                type: string;
-                                properties: {
-                                    speed: {
-                                        type: string;
-                                        minimum: number;
-                                        maximum: number;
-                                    };
-                                    accuracy: {
-                                        type: string;
-                                        minimum: number;
-                                        maximum: number;
-                                    };
-                                    completeness: {
-                                        type: string;
-                                        minimum: number;
-                                        maximum: number;
-                                    };
-                                };
-                            };
-                        };
-                        required: string[];
-                    };
-                };
-                required: string[];
-            };
-        };
-        learning_train: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    options: {
-                        type: string;
-                        properties: {
-                            batchSize: {
-                                type: string;
-                                default: number;
-                            };
-                            epochs: {
-                                type: string;
-                                default: number;
-                            };
-                            learningRate: {
-                                type: string;
-                                default: number;
-                            };
-                            minExperiences: {
-                                type: string;
-                                default: number;
-                            };
-                        };
-                    };
-                };
-                required: string[];
-            };
-        };
-        learning_metrics: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    period: {
-                        type: string;
-                        enum: string[];
-                        default: string;
-                        description: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-        learning_transfer: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sourceSessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    targetSessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    similarity: {
-                        type: string;
-                        minimum: number;
-                        maximum: number;
-                        default: number;
-                        description: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-        learning_explain: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    state: {
-                        type: string;
-                        description: string;
-                        properties: {
-                            taskDescription: {
-                                type: string;
-                            };
-                            availableTools: {
-                                type: string;
-                                items: {
-                                    type: string;
-                                };
-                            };
-                        };
-                        required: string[];
-                    };
-                };
-                required: string[];
-            };
-        };
-        experience_record: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    sessionId: {
-                        type: string;
-                        description: string;
-                    };
-                    toolName: {
-                        type: string;
-                        description: string;
-                    };
-                    args: {
-                        type: string;
-                        description: string;
-                    };
-                    result: {
-                        description: string;
-                    };
-                    outcome: {
-                        type: string;
-                        properties: {
-                            success: {
-                                type: string;
-                            };
-                            executionTime: {
-                                type: string;
-                            };
-                            tokensUsed: {
-                                type: string;
-                            };
-                            error: {
-                                type: string;
-                            };
-                        };
-                        required: string[];
-                    };
-                };
-                required: string[];
-            };
-        };
-        reward_signal: {
-            description: string;
-            inputSchema: {
-                type: string;
-                properties: {
-                    outcome: {
-                        type: string;
-                        properties: {
-                            success: {
-                                type: string;
-                            };
-                            executionTime: {
-                                type: string;
-                            };
-                            tokensUsed: {
-                                type: string;
-                            };
-                            result: {
-                                description: string;
-                            };
-                        };
-                        required: string[];
-                    };
-                    context: {
-                        type: string;
-                        properties: {
-                            userId: {
-                                type: string;
-                            };
-                            sessionId: {
-                                type: string;
-                            };
-                            taskType: {
-                                type: string;
-                                enum: string[];
-                            };
-                            timestamp: {
-                                type: string;
-                            };
-                        };
-                        required: string[];
-                    };
-                    userRating: {
-                        type: string;
-                        minimum: number;
-                        maximum: number;
-                        description: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-    };
-    /**
-     * Handle tool calls
-     */
-    handleToolCall(toolName: string, args: any): Promise<any>;
-}
-//# sourceMappingURL=mcp-learning-tools.d.ts.map

package/dist/mcp/learning/tools/mcp-learning-tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-learning-tools.d.ts","sourceRoot":"","sources":["../../../../src/mcp/learning/tools/mcp-learning-tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAQnE,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,eAAe,CAAkB;gBAE7B,eAAe,EAAE,eAAe;IAI5C;;OAEG;IACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwSlB;;OAEG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;CAiGhE"}