agentdb 1.0.0

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

@@ -0,0 +1,417 @@
+/**
+ * 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

@@ -0,0 +1,126 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}