agentdb 1.0.12 → 1.1.1

package/dist/plugins/implementations/decision-transformer.mjs

@@ -1,417 +0,0 @@
-/**
- * Decision Transformer Plugin
- *
- * Implements the Decision Transformer algorithm with 3-tier action selection:
- * - Tier 1: Exact retrieval (99% similarity)
- * - Tier 2: k-NN interpolation (95% similarity)
- * - Tier 3: Neural network generation
- *
- * Based on "Decision Transformer: Reinforcement Learning via Sequence Modeling"
- * https://arxiv.org/abs/2106.01345
- */
-import { BasePlugin } from '../base-plugin.mjs';
-/**
- * Decision layer network for neural action generation
- */
-class DecisionLayer {
-    constructor(inputSize = 2304, hiddenSize = 256, outputSize = 768) {
-        this.lastConfidence = 0;
-        this.inputSize = inputSize;
-        this.hiddenSize = hiddenSize;
-        this.outputSize = outputSize;
-        // Initialize weights with Xavier/He initialization
-        this.weights = {
-            W1: this.initializeWeights(inputSize * hiddenSize, inputSize),
-            b1: new Float32Array(hiddenSize),
-            W2: this.initializeWeights(hiddenSize * outputSize, hiddenSize),
-            b2: new Float32Array(outputSize),
-        };
-        // Initialize Adam optimizer state
-        this.optimizer = {
-            m_W1: new Float32Array(inputSize * hiddenSize),
-            v_W1: new Float32Array(inputSize * hiddenSize),
-            m_b1: new Float32Array(hiddenSize),
-            v_b1: new Float32Array(hiddenSize),
-            m_W2: new Float32Array(hiddenSize * outputSize),
-            v_W2: new Float32Array(hiddenSize * outputSize),
-            m_b2: new Float32Array(outputSize),
-            v_b2: new Float32Array(outputSize),
-            t: 0,
-        };
-    }
-    /**
-     * Initialize weights using He initialization
-     */
-    initializeWeights(size, fanIn) {
-        const weights = new Float32Array(size);
-        const std = Math.sqrt(2.0 / fanIn);
-        for (let i = 0; i < size; i++) {
-            weights[i] = (Math.random() * 2 - 1) * std;
-        }
-        return weights;
-    }
-    /**
-     * Forward pass through the network
-     */
-    predict(state, desiredReturn, history = []) {
-        // Prepare input
-        const returnEncoding = this.encodeReturn(desiredReturn);
-        const historyEncoding = history.length > 0 ? history : new Array(768).fill(0);
-        const input = new Float32Array([...state, ...returnEncoding, ...historyEncoding]);
-        // Layer 1: hidden = ReLU(W1 * input + b1)
-        const z1 = this.matmul(this.weights.W1, input, this.hiddenSize, this.inputSize);
-        const hidden = this.relu(this.add(z1, this.weights.b1));
-        // Layer 2: output = W2 * hidden + b2
-        const z2 = this.matmul(this.weights.W2, hidden, this.outputSize, this.hiddenSize);
-        const output = this.add(z2, this.weights.b2);
-        // Compute confidence
-        this.lastConfidence = this.computeConfidence(hidden, output);
-        return Array.from(output);
-    }
-    /**
-     * Train on a batch of experiences
-     */
-    trainBatch(states, actions, returns, learningRate = 0.001) {
-        let totalLoss = 0;
-        for (let i = 0; i < states.length; i++) {
-            const predicted = this.predict(states[i], returns[i]);
-            const target = actions[i];
-            // Compute MSE loss
-            const loss = this.computeLoss(predicted, target);
-            totalLoss += loss;
-            // Backward pass
-            this.backward(predicted, target, learningRate);
-        }
-        return totalLoss / states.length;
-    }
-    /**
-     * Compute MSE loss
-     */
-    computeLoss(predicted, target) {
-        let sum = 0;
-        for (let i = 0; i < predicted.length; i++) {
-            const diff = predicted[i] - target[i];
-            sum += diff * diff;
-        }
-        return sum / predicted.length;
-    }
-    /**
-     * Backward pass (simplified)
-     */
-    backward(predicted, target, learningRate) {
-        // Compute gradient
-        const gradient = new Float32Array(predicted.length);
-        for (let i = 0; i < predicted.length; i++) {
-            gradient[i] = predicted[i] - target[i];
-        }
-        // Update weights using Adam optimizer
-        this.optimizer.t++;
-        // Simplified Adam update (full implementation would update all layers)
-        const beta1 = 0.9;
-        const beta2 = 0.999;
-        const epsilon = 1e-8;
-        // Update bias for output layer as example
-        for (let i = 0; i < this.weights.b2.length; i++) {
-            const g = gradient[i];
-            this.optimizer.m_b2[i] = beta1 * this.optimizer.m_b2[i] + (1 - beta1) * g;
-            this.optimizer.v_b2[i] = beta2 * this.optimizer.v_b2[i] + (1 - beta2) * g * g;
-            const mHat = this.optimizer.m_b2[i] / (1 - Math.pow(beta1, this.optimizer.t));
-            const vHat = this.optimizer.v_b2[i] / (1 - Math.pow(beta2, this.optimizer.t));
-            this.weights.b2[i] -= learningRate * mHat / (Math.sqrt(vHat) + epsilon);
-        }
-    }
-    /**
-     * Encode desired return as positional embedding
-     */
-    encodeReturn(r) {
-        const encoding = new Float32Array(768);
-        for (let i = 0; i < 768; i++) {
-            const pos = r * 10000;
-            const div = Math.exp((i * -Math.log(10000)) / 768);
-            encoding[i] = i % 2 === 0 ? Math.sin(pos * div) : Math.cos(pos * div);
-        }
-        return Array.from(encoding);
-    }
-    /**
-     * Compute confidence from network activations
-     */
-    computeConfidence(hidden, output) {
-        const hiddenNorm = Math.sqrt(Array.from(hidden).reduce((sum, x) => sum + x * x, 0));
-        const outputNorm = Math.sqrt(Array.from(output).reduce((sum, x) => sum + x * x, 0));
-        const hiddenScore = 1.0 - Math.abs(hiddenNorm - 50) / 100;
-        const outputScore = 1.0 - Math.abs(outputNorm - 10) / 20;
-        return Math.max(0, Math.min(1, (hiddenScore + outputScore) / 2));
-    }
-    /**
-     * Matrix-vector multiplication
-     */
-    matmul(matrix, vector, rows, cols) {
-        const result = new Float32Array(rows);
-        for (let i = 0; i < rows; i++) {
-            let sum = 0;
-            for (let j = 0; j < cols; j++) {
-                sum += matrix[i * cols + j] * vector[j];
-            }
-            result[i] = sum;
-        }
-        return result;
-    }
-    /**
-     * ReLU activation
-     */
-    relu(x) {
-        return x.map(val => Math.max(0, val));
-    }
-    /**
-     * Vector addition
-     */
-    add(a, b) {
-        const result = new Float32Array(a.length);
-        for (let i = 0; i < a.length; i++) {
-            result[i] = a[i] + b[i];
-        }
-        return result;
-    }
-    getLastConfidence() {
-        return this.lastConfidence;
-    }
-}
-/**
- * Decision Transformer Plugin Implementation
- */
-export class DecisionTransformerPlugin extends BasePlugin {
-    constructor() {
-        super(...arguments);
-        this.name = 'decision-transformer';
-        this.version = '1.0.0';
-        this.tier1Threshold = 0.99;
-        this.tier2Threshold = 0.95;
-        this.kNeighbors = 5;
-    }
-    /**
-     * Initialize the Decision Transformer plugin
-     */
-    async onInitialize() {
-        // Initialize decision layer
-        const stateSize = this.config.algorithm.stateDim || 768;
-        const hiddenSize = this.config.algorithm.hiddenSize || 256;
-        this.decisionLayer = new DecisionLayer(stateSize * 3, hiddenSize, stateSize);
-        // Get configuration parameters
-        this.tier1Threshold = this.config.algorithm.tier1Threshold || 0.99;
-        this.tier2Threshold = this.config.algorithm.tier2Threshold || 0.95;
-        this.kNeighbors = this.config.algorithm.kNeighbors || 5;
-    }
-    /**
-     * Select action using 3-tier strategy
-     *
-     * @param state - Current state vector
-     * @param context - Optional context including desired return
-     * @returns Selected action
-     */
-    async selectAction(state, context) {
-        this.checkInitialized();
-        const desiredReturn = context?.desiredReturn || 1.0;
-        const startTime = Date.now();
-        // Tier 1: Exact retrieval
-        const tier1Action = await this.tryExactRetrieval(state, desiredReturn);
-        if (tier1Action) {
-            return {
-                ...tier1Action,
-                metadata: { ...tier1Action.metadata, latency: Date.now() - startTime },
-            };
-        }
-        // Tier 2: k-NN interpolation
-        const tier2Action = await this.tryKNNInterpolation(state, desiredReturn);
-        if (tier2Action) {
-            return {
-                ...tier2Action,
-                metadata: { ...tier2Action.metadata, latency: Date.now() - startTime },
-            };
-        }
-        // Tier 3: Neural generation
-        const tier3Action = await this.useNeuralGeneration(state, desiredReturn, context);
-        return {
-            ...tier3Action,
-            metadata: { ...tier3Action.metadata, latency: Date.now() - startTime },
-        };
-    }
-    /**
-     * Tier 1: Try exact retrieval
-     */
-    async tryExactRetrieval(state, desiredReturn) {
-        const results = await this.retrieveSimilar(state, 1);
-        if (results.length === 0 || results[0].score < this.tier1Threshold) {
-            return null;
-        }
-        const best = results[0];
-        if (!best.metadata) {
-            return null;
-        }
-        const returnToGo = this.computeReturnToGo(best.metadata);
-        if (returnToGo >= desiredReturn) {
-            return {
-                id: best.id,
-                embedding: best.metadata.action,
-                source: 'exact_retrieval',
-                confidence: best.score,
-                metadata: { tier: 1, returnToGo },
-            };
-        }
-        return null;
-    }
-    /**
-     * Tier 2: Try k-NN interpolation
-     */
-    async tryKNNInterpolation(state, desiredReturn) {
-        const results = await this.retrieveSimilar(state, this.kNeighbors);
-        // Filter by similarity and return
-        const successful = results.filter(r => r.metadata && r.score >= this.tier2Threshold && this.computeReturnToGo(r.metadata) >= desiredReturn);
-        if (successful.length < 3 || !successful[0].metadata) {
-            return null;
-        }
-        // Weighted average of actions
-        const weights = successful.map(r => r.score);
-        const totalWeight = weights.reduce((sum, w) => sum + w, 0);
-        const actionDim = successful[0].metadata.action.length;
-        const avgEmbedding = new Float32Array(actionDim);
-        for (let i = 0; i < successful.length; i++) {
-            const weight = weights[i] / totalWeight;
-            const action = successful[i].metadata.action;
-            for (let j = 0; j < actionDim; j++) {
-                avgEmbedding[j] += action[j] * weight;
-            }
-        }
-        return {
-            id: `interpolated_${successful.length}`,
-            embedding: Array.from(avgEmbedding),
-            source: 'knn_interpolation',
-            confidence: totalWeight / successful.length,
-            metadata: { tier: 2, kNeighbors: successful.length },
-        };
-    }
-    /**
-     * Tier 3: Use neural network generation
-     */
-    async useNeuralGeneration(state, desiredReturn, context) {
-        // Get history from context if available
-        const history = context?.history
-            ? this.encodeHistory(context.history)
-            : new Array(768).fill(0);
-        // Generate action using decision layer
-        const actionEmbedding = this.decisionLayer.predict(state, desiredReturn, history);
-        return {
-            id: 'neural_generated',
-            embedding: actionEmbedding,
-            source: 'neural_network',
-            confidence: this.decisionLayer.getLastConfidence(),
-            metadata: { tier: 3 },
-        };
-    }
-    /**
-     * Train the decision layer on stored experiences
-     */
-    async train(options) {
-        this.checkInitialized();
-        const epochs = options?.epochs || this.config.training.epochs || 10;
-        const batchSize = options?.batchSize || this.config.training.batchSize;
-        const learningRate = options?.learningRate || this.config.algorithm.learningRate;
-        // Fetch all experiences (in production, batch this)
-        const allExperiences = await this.getAllExperiences();
-        if (allExperiences.length < this.config.training.minExperiences) {
-            throw new Error(`Not enough experiences to train. Need ${this.config.training.minExperiences}, have ${allExperiences.length}`);
-        }
-        let totalLoss = 0;
-        const gamma = this.config.algorithm.discountFactor || 0.99;
-        // Group by episode and compute returns
-        const episodes = this.groupByEpisode(allExperiences);
-        for (let epoch = 0; epoch < epochs; epoch++) {
-            let epochLoss = 0;
-            for (const episode of episodes) {
-                const rewards = episode.map(e => e.reward);
-                const returns = this.computeReturns(rewards, gamma);
-                // Train on each step
-                const states = episode.map(e => e.state);
-                const actions = episode.map(e => e.action);
-                epochLoss += this.decisionLayer.trainBatch(states, actions, returns, learningRate);
-            }
-            totalLoss = epochLoss / episodes.length;
-            if (options?.verbose) {
-                console.log(`Epoch ${epoch + 1}/${epochs}: Loss = ${totalLoss.toFixed(4)}`);
-            }
-        }
-        return {
-            loss: totalLoss,
-            episodesTrained: episodes.length,
-        };
-    }
-    /**
-     * Compute return-to-go from experience metadata
-     */
-    computeReturnToGo(metadata) {
-        return metadata.returnToGo || metadata.reward || 0;
-    }
-    /**
-     * Encode history as average of recent states
-     */
-    encodeHistory(history) {
-        if (history.length === 0) {
-            return new Array(768).fill(0);
-        }
-        const recent = history.slice(-5); // Last 5 experiences
-        const avg = new Float32Array(recent[0].state.length);
-        for (const exp of recent) {
-            for (let i = 0; i < exp.state.length; i++) {
-                avg[i] += exp.state[i];
-            }
-        }
-        for (let i = 0; i < avg.length; i++) {
-            avg[i] /= recent.length;
-        }
-        return Array.from(avg);
-    }
-    /**
-     * Get all experiences (helper method)
-     */
-    async getAllExperiences() {
-        // This is a simplified version - in production, batch fetch
-        const stats = this.vectorDB.stats();
-        const experiences = [];
-        // For now, return empty - proper implementation would fetch from DB
-        // This would need backend support to efficiently fetch all vectors
-        return experiences;
-    }
-    /**
-     * Group experiences by episode
-     */
-    groupByEpisode(experiences) {
-        const episodes = new Map();
-        for (const exp of experiences) {
-            const episodeId = exp.episodeId || 'default';
-            if (!episodes.has(episodeId)) {
-                episodes.set(episodeId, []);
-            }
-            episodes.get(episodeId).push(exp);
-        }
-        // Sort each episode by step index
-        for (const episode of episodes.values()) {
-            episode.sort((a, b) => (a.stepIndex || 0) - (b.stepIndex || 0));
-        }
-        return Array.from(episodes.values());
-    }
-    /**
-     * Save model weights
-     */
-    async onSave(path) {
-        // Save decision layer weights
-        // In production, serialize weights to file
-        console.log(`Saving Decision Transformer model to ${path}`);
-    }
-    /**
-     * Load model weights
-     */
-    async onLoad(path) {
-        // Load decision layer weights
-        // In production, deserialize weights from file
-        console.log(`Loading Decision Transformer model from ${path}`);
-    }
-}

package/dist/plugins/implementations/federated-learning.d.ts

@@ -1,126 +0,0 @@
-/**
- * Federated Learning Plugin
- *
- * Implements privacy-preserving distributed learning where multiple
- * agents learn collaboratively without sharing raw data.
- *
- * Key features:
- * - Client-side model updates
- * - Secure aggregation of gradients
- * - Differential privacy
- * - Byzantine fault tolerance
- * - Personalized federated learning
- */
-import { BasePlugin } from '../base-plugin';
-import { Action, Context, Experience, TrainOptions, TrainingMetrics, Vector } from '../learning-plugin.interface';
-/**
- * Federated Learning Plugin Implementation
- */
-export declare class FederatedLearningPlugin extends BasePlugin {
-    name: string;
-    version: string;
-    private experiences;
-    private clients;
-    private globalWeights;
-    private roundNumber;
-    private aggregationStrategy;
-    private privacyBudget;
-    private noisyScale;
-    private clippingNorm;
-    private byzantineFraction;
-    private useMedianAggregation;
-    constructor(config?: Partial<any>);
-    /**
-     * Override to skip initialization check for in-memory operation
-     */
-    protected checkInitialized(): void;
-    /**
-     * Override to store experiences in-memory without vectorDB
-     */
-    storeExperience(experience: Experience): Promise<void>;
-    /**
-     * Override to retrieve from local experiences
-     */
-    retrieveSimilar(state: number[], k: number): Promise<import('../..').SearchResult<Experience>[]>;
-    /**
-     * Initialize global model weights
-     */
-    private initializeGlobalModel;
-    /**
-     * Register a new federated client
-     */
-    registerClient(clientId: string): Promise<void>;
-    /**
-     * Client performs local training
-     */
-    trainLocalModel(clientId: string, experiences: Experience[], epochs?: number): Promise<Map<string, Vector>>;
-    /**
-     * Compute gradients for experience
-     */
-    private computeGradients;
-    /**
-     * Add differential privacy noise to gradients
-     */
-    private addDifferentialPrivacy;
-    /**
-     * Clip gradients for privacy
-     */
-    private clipGradients;
-    /**
-     * Aggregate client updates into global model
-     */
-    aggregateUpdates(clientIds: string[]): Promise<void>;
-    /**
-     * FedAvg: Weighted average by data count
-     */
-    private aggregateFedAvg;
-    /**
-     * FedProx: Proximal term to handle heterogeneity
-     */
-    private aggregateFedProx;
-    /**
-     * FedOpt: Server-side adaptive optimization
-     */
-    private aggregateFedOpt;
-    /**
-     * SCAFFOLD: Control variates to reduce client drift
-     */
-    private aggregateScaffold;
-    /**
-     * Detect and filter Byzantine clients
-     */
-    private filterByzantineClients;
-    /**
-     * Broadcast updated global model to all clients
-     */
-    private broadcastGlobalModel;
-    /**
-     * Encode state vector for transmission
-     */
-    private encodeState;
-    /**
-     * Select action using current global model
-     */
-    selectAction(state: Vector, context?: Context): Promise<Action>;
-    /**
-     * Forward pass through layer
-     */
-    private forward;
-    /**
-     * Train using federated learning rounds
-     */
-    train(options?: TrainOptions): Promise<TrainingMetrics>;
-    /**
-     * Get global model weights
-     */
-    getGlobalWeights(): Map<string, Vector>;
-    /**
-     * Get client statistics
-     */
-    getClientStats(): Array<{
-        id: string;
-        dataCount: number;
-        reputation: number;
-    }>;
-}
-//# sourceMappingURL=federated-learning.d.ts.map

package/dist/plugins/implementations/federated-learning.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"federated-learning.d.ts","sourceRoot":"","sources":["../../../src/plugins/implementations/federated-learning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,MAAM,EACN,OAAO,EACP,UAAU,EACV,YAAY,EACZ,eAAe,EACf,MAAM,EACP,MAAM,8BAA8B,CAAC;AAkBtC;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,UAAU;IACrD,IAAI,SAAwB;IAC5B,OAAO,SAAW;IAElB,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,mBAAmB,CAAiC;IAG5D,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,YAAY,CAAe;IAGnC,OAAO,CAAC,iBAAiB,CAAe;IACxC,OAAO,CAAC,oBAAoB,CAAkB;gBAElC,MAAM,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC;IAgBjC;;OAEG;IACH,SAAS,CAAC,gBAAgB,IAAI,IAAI;IAIlC;;OAEG;IACG,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5D;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,CAAC;IAStG;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBrD;;OAEG;IACG,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,UAAU,EAAE,EACzB,MAAM,GAAE,MAAU,GACjB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAgC/B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAqBxB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;OAEG;IACH,OAAO,CAAC,aAAa;IAUrB;;OAEG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B1D;;OAEG;IACH,OAAO,CAAC,eAAe;IAwBvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAwBxB;;OAEG;IACH,OAAO,CAAC,eAAe;IA0BvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA2BzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAoD9B;;OAEG;YACW,oBAAoB;IAQlC;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBrE;;OAEG;IACH,OAAO,CAAC,OAAO;IAWf;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC;IAyC7D;;OAEG;IACH,gBAAgB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIvC;;OAEG;IACH,cAAc,IAAI,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CAO/E"}