agentdb 1.0.0

package/dist/plugins/implementations/sarsa.mjs

@@ -0,0 +1,342 @@
+/**
+ * SARSA Plugin
+ *
+ * Implements the SARSA (State-Action-Reward-State-Action) algorithm
+ * with eligibility traces (SARSA(λ)).
+ *
+ * SARSA is an on-policy TD control algorithm that learns from the
+ * actual actions taken by the current policy, unlike Q-Learning which
+ * is off-policy.
+ *
+ * Key features:
+ * - On-policy learning
+ * - Eligibility traces for faster learning
+ * - Epsilon-greedy exploration
+ * - More conservative than Q-Learning
+ */
+import { BasePlugin } from '../base-plugin.mjs';
+/**
+ * Eligibility trace for state-action pairs
+ */
+class EligibilityTrace {
+    constructor(lambda = 0.9, gamma = 0.99) {
+        this.traces = new Map();
+        this.lambda = lambda;
+        this.gamma = gamma;
+    }
+    /**
+     * Get trace value for state-action pair
+     */
+    get(stateKey, actionKey) {
+        return this.traces.get(stateKey)?.get(actionKey) || 0;
+    }
+    /**
+     * Update trace for state-action pair
+     */
+    update(stateKey, actionKey, value = 1) {
+        if (!this.traces.has(stateKey)) {
+            this.traces.set(stateKey, new Map());
+        }
+        this.traces.get(stateKey).set(actionKey, value);
+    }
+    /**
+     * Decay all traces
+     */
+    decay() {
+        const decayFactor = this.gamma * this.lambda;
+        for (const [stateKey, actions] of this.traces.entries()) {
+            for (const [actionKey, value] of actions.entries()) {
+                const newValue = value * decayFactor;
+                if (newValue < 1e-6) {
+                    actions.delete(actionKey);
+                }
+                else {
+                    actions.set(actionKey, newValue);
+                }
+            }
+            if (actions.size === 0) {
+                this.traces.delete(stateKey);
+            }
+        }
+    }
+    /**
+     * Reset all traces
+     */
+    reset() {
+        this.traces.clear();
+    }
+    /**
+     * Get all non-zero traces
+     */
+    getAllTraces() {
+        const result = [];
+        for (const [stateKey, actions] of this.traces.entries()) {
+            for (const [actionKey, value] of actions.entries()) {
+                result.push({ stateKey, actionKey, value });
+            }
+        }
+        return result;
+    }
+}
+/**
+ * SARSA Plugin Implementation
+ */
+export class SARSAPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.name = 'sarsa';
+        this.version = '1.0.0';
+        this.qTable = new Map();
+        this.epsilon = 1.0;
+        this.epsilonMin = 0.01;
+        this.epsilonDecay = 0.995;
+        this.lambda = 0.9;
+        this.lastState = null;
+        this.lastAction = null;
+    }
+    /**
+     * Initialize SARSA plugin
+     */
+    async onInitialize() {
+        // Initialize epsilon
+        this.epsilon = this.config.algorithm.epsilonStart || 1.0;
+        this.epsilonMin = this.config.algorithm.epsilonEnd || 0.01;
+        this.epsilonDecay = this.config.algorithm.epsilonDecay || 0.995;
+        // Initialize lambda (eligibility trace decay)
+        this.lambda = this.config.algorithm.lambda || 0.9;
+        // Initialize eligibility traces
+        const gamma = this.config.algorithm.discountFactor || 0.99;
+        this.eligibilityTraces = new EligibilityTrace(this.lambda, gamma);
+    }
+    /**
+     * Select action using epsilon-greedy policy
+     *
+     * @param state - Current state vector
+     * @param context - Optional context
+     * @returns Selected action
+     */
+    async selectAction(state, context) {
+        this.checkInitialized();
+        // Epsilon-greedy exploration
+        if (Math.random() < this.epsilon) {
+            return this.randomAction(state);
+        }
+        // Exploit: Select action with highest Q-value
+        return this.greedyAction(state);
+    }
+    /**
+     * Select random action (exploration)
+     */
+    async randomAction(state) {
+        // Find similar states to get action space
+        const similar = await this.retrieveSimilar(state, 10);
+        if (similar.length === 0) {
+            // No similar states, return random embedding
+            return {
+                id: 'random',
+                embedding: Array.from({ length: 768 }, () => Math.random() * 2 - 1),
+                source: 'policy',
+                confidence: 0,
+                metadata: { exploration: true },
+            };
+        }
+        // Random action from similar states
+        const randomIdx = Math.floor(Math.random() * similar.length);
+        const randomExp = similar[randomIdx];
+        if (!randomExp.metadata) {
+            // Fallback to random embedding
+            return {
+                id: 'random',
+                embedding: Array.from({ length: 768 }, () => Math.random() * 2 - 1),
+                source: 'policy',
+                confidence: 0,
+                metadata: { exploration: true },
+            };
+        }
+        return {
+            id: randomExp.id,
+            embedding: randomExp.metadata.action,
+            source: 'policy',
+            confidence: 0,
+            metadata: { exploration: true },
+        };
+    }
+    /**
+     * Select greedy action (exploitation)
+     */
+    async greedyAction(state) {
+        const stateKey = this.hashState(state);
+        // Get Q-values for this state
+        const qValues = this.qTable.get(stateKey);
+        if (!qValues || qValues.size === 0) {
+            // No Q-values yet, explore similar states
+            const similar = await this.retrieveSimilar(state, 1);
+            if (similar.length > 0 && similar[0].metadata) {
+                return {
+                    id: similar[0].id,
+                    embedding: similar[0].metadata.action,
+                    source: 'policy',
+                    confidence: similar[0].score,
+                    metadata: { exploration: false },
+                };
+            }
+            // Fallback to random
+            return this.randomAction(state);
+        }
+        // Find action with maximum Q-value
+        let maxQ = -Infinity;
+        let bestAction = '';
+        for (const [action, qValue] of qValues.entries()) {
+            if (qValue > maxQ) {
+                maxQ = qValue;
+                bestAction = action;
+            }
+        }
+        // Retrieve action embedding from storage
+        const actionData = await this.getActionEmbedding(bestAction);
+        return {
+            id: bestAction,
+            embedding: actionData,
+            source: 'policy',
+            confidence: this.normalizeQValue(maxQ),
+            metadata: { exploration: false, qValue: maxQ },
+        };
+    }
+    /**
+     * Store experience and perform SARSA update
+     *
+     * SARSA uses the actual next action taken, not the max Q-value
+     */
+    async onStoreExperience(experience) {
+        // SARSA requires knowing the next action (on-policy)
+        if (this.lastState !== null && this.lastAction !== null) {
+            await this.sarsaUpdate(this.lastState, this.lastAction, experience.reward, experience.state, experience.action, experience.done);
+        }
+        // Store current state and action for next update
+        this.lastState = experience.state;
+        this.lastAction = experience.action;
+        // Reset on episode end
+        if (experience.done) {
+            this.lastState = null;
+            this.lastAction = null;
+            this.eligibilityTraces.reset();
+        }
+    }
+    /**
+     * Perform SARSA(λ) update with eligibility traces
+     */
+    async sarsaUpdate(state, action, reward, nextState, nextAction, done) {
+        const learningRate = this.config.algorithm.learningRate || 0.001;
+        const gamma = this.config.algorithm.discountFactor || 0.99;
+        const stateKey = this.hashState(state);
+        const actionKey = this.hashAction(action);
+        const nextStateKey = this.hashState(nextState);
+        const nextActionKey = this.hashAction(nextAction);
+        // Get current Q-values
+        const currentQ = this.getQValue(stateKey, actionKey);
+        const nextQ = done ? 0 : this.getQValue(nextStateKey, nextActionKey);
+        // Compute TD error
+        const tdError = reward + gamma * nextQ - currentQ;
+        // Update eligibility trace for current state-action
+        this.eligibilityTraces.update(stateKey, actionKey, 1);
+        // Update all Q-values proportional to their eligibility traces
+        const traces = this.eligibilityTraces.getAllTraces();
+        for (const { stateKey: sKey, actionKey: aKey, value: trace } of traces) {
+            const oldQ = this.getQValue(sKey, aKey);
+            const newQ = oldQ + learningRate * tdError * trace;
+            this.setQValue(sKey, aKey, newQ);
+        }
+        // Decay eligibility traces
+        this.eligibilityTraces.decay();
+    }
+    /**
+     * Train SARSA on stored experiences
+     *
+     * For online learning, this is called after each experience.
+     * For offline learning, this processes batches of episodes.
+     */
+    async train(options) {
+        this.checkInitialized();
+        // SARSA is typically online, so training happens during experience storage
+        // However, we can still compute metrics here
+        let avgQValue = 0;
+        let qCount = 0;
+        for (const [_, actions] of this.qTable.entries()) {
+            for (const qValue of actions.values()) {
+                avgQValue += qValue;
+                qCount++;
+            }
+        }
+        avgQValue = qCount > 0 ? avgQValue / qCount : 0;
+        // Decay epsilon
+        this.epsilon = Math.max(this.epsilonMin, this.epsilon * this.epsilonDecay);
+        return {
+            loss: 0, // Not computed in online SARSA
+            avgQValue,
+            epsilon: this.epsilon,
+        };
+    }
+    /**
+     * Get Q-value for state-action pair
+     */
+    getQValue(stateKey, actionKey) {
+        const qValues = this.qTable.get(stateKey);
+        return qValues?.get(actionKey) || 0;
+    }
+    /**
+     * Set Q-value for state-action pair
+     */
+    setQValue(stateKey, actionKey, value) {
+        if (!this.qTable.has(stateKey)) {
+            this.qTable.set(stateKey, new Map());
+        }
+        this.qTable.get(stateKey).set(actionKey, value);
+    }
+    /**
+     * Hash state vector to string key
+     */
+    hashState(state) {
+        // Simple hash - in production, use better hashing or clustering
+        return state.slice(0, 10).map((x) => x.toFixed(2)).join(',');
+    }
+    /**
+     * Hash action to string key
+     */
+    hashAction(action) {
+        if (typeof action === 'string') {
+            return action;
+        }
+        if (Array.isArray(action)) {
+            return action.slice(0, 10).map((x) => x.toFixed(2)).join(',');
+        }
+        return String(action);
+    }
+    /**
+     * Get action embedding from ID
+     */
+    async getActionEmbedding(actionId) {
+        // In production, retrieve from database
+        // For now, return random embedding
+        return Array.from({ length: 768 }, () => Math.random() * 2 - 1);
+    }
+    /**
+     * Normalize Q-value to 0-1 confidence
+     */
+    normalizeQValue(qValue) {
+        return 1 / (1 + Math.exp(-qValue)); // Sigmoid
+    }
+    /**
+     * Save Q-table and eligibility traces
+     */
+    async onSave(path) {
+        console.log(`Saving SARSA model to ${path}`);
+        // In production, serialize Q-table and traces to file
+    }
+    /**
+     * Load Q-table and eligibility traces
+     */
+    async onLoad(path) {
+        console.log(`Loading SARSA model from ${path}`);
+        // In production, deserialize Q-table and traces from file
+    }
+}

package/dist/plugins/index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * SQLite Vector Learning Plugins
+ *
+ * Extensible plugin system for custom learning methodologies using vector databases.
+ *
+ * This module provides:
+ * - Plugin interface definitions
+ * - Plugin registry for discovery and management
+ * - Base plugin implementation
+ * - Configuration validation
+ *
+ * @module plugins
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   getRegistry,
+ *   registerPlugin,
+ *   loadPlugin,
+ *   BasePlugin,
+ *   type LearningPlugin,
+ *   type PluginConfig
+ * } from '@agentdb/plugins';
+ *
+ * // Register a plugin
+ * registerPlugin({
+ *   name: 'my-q-learning',
+ *   version: '1.0.0',
+ *   description: 'Custom Q-Learning implementation',
+ *   baseAlgorithm: 'q_learning',
+ *   factory: (config) => new MyQLearningPlugin(config)
+ * });
+ *
+ * // Load and use plugin
+ * const plugin = await loadPlugin('my-q-learning', {
+ *   config: {
+ *     training: { batchSize: 64 }
+ *   },
+ *   initialize: true
+ * });
+ *
+ * // Use plugin for learning
+ * const action = await plugin.selectAction(stateVector);
+ * await plugin.storeExperience({
+ *   state: stateVector,
+ *   action,
+ *   reward: 1.0,
+ *   nextState: nextStateVector,
+ *   done: false
+ * });
+ * await plugin.train();
+ * ```
+ */
+export { type LearningPlugin, type PluginConfig, type AlgorithmConfig, type StateConfig, type ActionConfig, type RewardConfig, type ExperienceReplayConfig, type StorageConfig, type TrainingConfig, type MonitoringConfig, type ExtensionConfig, type Vector, type Experience, type Action, type Context, type Outcome, type TrainOptions, type TrainingCallback, type TrainingMetrics, type PluginMetrics, type PluginFactory, type PluginMetadata } from './interface';
+export { PluginRegistry, getRegistry, registerPlugin, loadPlugin, type PluginLoadOptions, type PluginSearchCriteria, PluginError } from './registry';
+export { BasePlugin } from './base-plugin';
+export { validatePluginConfig, validateRequired, getErrorSummary, type ValidationResult, type ValidationError } from './validator';
+/**
+ * Plugin system version
+ */
+export declare const PLUGIN_SYSTEM_VERSION = "1.0.0";
+/**
+ * Supported plugin API version
+ */
+export declare const PLUGIN_API_VERSION = "1.0.0";
+/**
+ * Create a plugin configuration with defaults
+ *
+ * @param overrides - Configuration overrides
+ * @returns Plugin configuration with defaults
+ *
+ * @example
+ * ```typescript
+ * const config = createDefaultConfig({
+ *   name: 'my-plugin',
+ *   version: '1.0.0',
+ *   description: 'My custom plugin',
+ *   baseAlgorithm: 'q_learning'
+ * });
+ * ```
+ */
+import type { PluginConfig as IPluginConfig } from './interface';
+export declare function createDefaultConfig(overrides: Partial<IPluginConfig>): IPluginConfig;
+/**
+ * Check if plugin system is initialized
+ *
+ * @returns Whether registry has plugins
+ */
+export declare function isInitialized(): boolean;
+/**
+ * Get plugin system information
+ *
+ * @returns System information
+ */
+export declare function getSystemInfo(): {
+    systemVersion: string;
+    apiVersion: string;
+    totalPlugins: number;
+    activePlugins: number;
+    availablePlugins: {
+        name: any;
+        version: any;
+        baseAlgorithm: any;
+    }[];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAIH,OAAO,EAEL,KAAK,cAAc,EAGnB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAGpB,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,MAAM,EACX,KAAK,OAAO,EACZ,KAAK,OAAO,EAGZ,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,aAAa,EAGlB,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAIrB,OAAO,EAEL,cAAc,EAGd,WAAW,EACX,cAAc,EACd,UAAU,EAGV,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAGzB,WAAW,EACZ,MAAM,YAAY,CAAC;AAIpB,OAAO,EAEL,UAAU,EACX,MAAM,eAAe,CAAC;AAIvB,OAAO,EAEL,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EAGf,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAIrB;;GAEG;AACH,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAI1C;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,YAAY,IAAI,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjE,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,aAAa,CAkEpF;AAID;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAGvC;AAED;;;;GAIG;AACH,wBAAgB,aAAa;;;;;;;;;;EAgB5B"}

package/dist/plugins/index.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * SQLite Vector Learning Plugins
+ *
+ * Extensible plugin system for custom learning methodologies using vector databases.
+ *
+ * This module provides:
+ * - Plugin interface definitions
+ * - Plugin registry for discovery and management
+ * - Base plugin implementation
+ * - Configuration validation
+ *
+ * @module plugins
+ * @packageDocumentation
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   getRegistry,
+ *   registerPlugin,
+ *   loadPlugin,
+ *   BasePlugin,
+ *   type LearningPlugin,
+ *   type PluginConfig
+ * } from '@agentdb/plugins';
+ *
+ * // Register a plugin
+ * registerPlugin({
+ *   name: 'my-q-learning',
+ *   version: '1.0.0',
+ *   description: 'Custom Q-Learning implementation',
+ *   baseAlgorithm: 'q_learning',
+ *   factory: (config) => new MyQLearningPlugin(config)
+ * });
+ *
+ * // Load and use plugin
+ * const plugin = await loadPlugin('my-q-learning', {
+ *   config: {
+ *     training: { batchSize: 64 }
+ *   },
+ *   initialize: true
+ * });
+ *
+ * // Use plugin for learning
+ * const action = await plugin.selectAction(stateVector);
+ * await plugin.storeExperience({
+ *   state: stateVector,
+ *   action,
+ *   reward: 1.0,
+ *   nextState: nextStateVector,
+ *   done: false
+ * });
+ * await plugin.train();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_API_VERSION = exports.PLUGIN_SYSTEM_VERSION = exports.getErrorSummary = exports.validateRequired = exports.validatePluginConfig = exports.BasePlugin = exports.PluginError = exports.loadPlugin = exports.registerPlugin = exports.getRegistry = exports.PluginRegistry = void 0;
+exports.createDefaultConfig = createDefaultConfig;
+exports.isInitialized = isInitialized;
+exports.getSystemInfo = getSystemInfo;
+// ============ Plugin Registry ============
+var registry_1 = require("./registry");
+// Registry class
+Object.defineProperty(exports, "PluginRegistry", { enumerable: true, get: function () { return registry_1.PluginRegistry; } });
+// Registry functions
+Object.defineProperty(exports, "getRegistry", { enumerable: true, get: function () { return registry_1.getRegistry; } });
+Object.defineProperty(exports, "registerPlugin", { enumerable: true, get: function () { return registry_1.registerPlugin; } });
+Object.defineProperty(exports, "loadPlugin", { enumerable: true, get: function () { return registry_1.loadPlugin; } });
+// Errors
+Object.defineProperty(exports, "PluginError", { enumerable: true, get: function () { return registry_1.PluginError; } });
+// ============ Base Plugin ============
+var base_plugin_1 = require("./base-plugin");
+// Base plugin class
+Object.defineProperty(exports, "BasePlugin", { enumerable: true, get: function () { return base_plugin_1.BasePlugin; } });
+// ============ Validation ============
+var validator_1 = require("./validator");
+// Validation functions
+Object.defineProperty(exports, "validatePluginConfig", { enumerable: true, get: function () { return validator_1.validatePluginConfig; } });
+Object.defineProperty(exports, "validateRequired", { enumerable: true, get: function () { return validator_1.validateRequired; } });
+Object.defineProperty(exports, "getErrorSummary", { enumerable: true, get: function () { return validator_1.getErrorSummary; } });
+// ============ Version Information ============
+/**
+ * Plugin system version
+ */
+exports.PLUGIN_SYSTEM_VERSION = '1.0.0';
+/**
+ * Supported plugin API version
+ */
+exports.PLUGIN_API_VERSION = '1.0.0';
+function createDefaultConfig(overrides) {
+    return {
+        name: overrides.name || 'unnamed-plugin',
+        version: overrides.version || '1.0.0',
+        description: overrides.description || 'A learning plugin',
+        baseAlgorithm: overrides.baseAlgorithm || 'custom',
+        algorithm: {
+            type: 'custom',
+            learningRate: 0.001,
+            discountFactor: 0.99,
+            ...overrides.algorithm
+        },
+        state: {
+            dimension: 768,
+            preprocessing: ['normalize'],
+            ...overrides.state
+        },
+        action: {
+            type: 'discrete',
+            spaceSize: 100,
+            selectionStrategy: 'epsilon_greedy',
+            ...overrides.action
+        },
+        reward: {
+            type: 'success_based',
+            ...overrides.reward
+        },
+        experienceReplay: overrides.experienceReplay || {
+            type: 'uniform',
+            capacity: 10000
+        },
+        storage: {
+            backend: 'agentdb',
+            path: './.rl/plugin.db',
+            hnsw: {
+                enabled: true,
+                M: 16,
+                efConstruction: 200
+            },
+            ...overrides.storage
+        },
+        training: {
+            batchSize: 32,
+            epochs: 10,
+            minExperiences: 100,
+            trainEvery: 100,
+            ...overrides.training
+        },
+        monitoring: {
+            trackMetrics: ['success_rate', 'avg_reward', 'loss'],
+            logInterval: 10,
+            saveCheckpoints: true,
+            checkpointInterval: 50,
+            ...overrides.monitoring
+        },
+        extensions: overrides.extensions || []
+    };
+}
+const registry_2 = require("./registry");
+/**
+ * Check if plugin system is initialized
+ *
+ * @returns Whether registry has plugins
+ */
+function isInitialized() {
+    const registry = (0, registry_2.getRegistry)();
+    return registry.list().length > 0;
+}
+/**
+ * Get plugin system information
+ *
+ * @returns System information
+ */
+function getSystemInfo() {
+    const registry = (0, registry_2.getRegistry)();
+    const plugins = registry.list();
+    const activePlugins = registry.listActive();
+    return {
+        systemVersion: exports.PLUGIN_SYSTEM_VERSION,
+        apiVersion: exports.PLUGIN_API_VERSION,
+        totalPlugins: plugins.length,
+        activePlugins: activePlugins.length,
+        availablePlugins: plugins.map((p) => ({
+            name: p.name,
+            version: p.version,
+            baseAlgorithm: p.baseAlgorithm
+        }))
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/plugins/index.js.map

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