agentic-flow 2.0.1-alpha.9 → 2.0.2-alpha

package/dist/core/agentdb-wrapper-enhanced.js

@@ -1,732 +0,0 @@
-/**
- * Enhanced AgentDBWrapper - Full integration with Attention & GNN
- *
- * Provides advanced features:
- * - 5 Attention Mechanisms (Flash, Multi-Head, Linear, Hyperbolic, MoE)
- * - GNN Query Refinement (+12.4% recall improvement)
- * - GraphRoPE Position Embeddings
- * - Attention-based Multi-Agent Coordination
- *
- * @module agentdb-wrapper-enhanced
- * @version 2.0.0-alpha
- */
-import { AgentDB } from 'agentdb';
-/**
- * Enhanced wrapper class with full Attention & GNN support
- *
- * @example Flash Attention
- * ```typescript
- * const wrapper = new EnhancedAgentDBWrapper({
- *   dimension: 768,
- *   enableAttention: true,
- *   attentionConfig: {
- *     type: 'flash',
- *     numHeads: 8,
- *     headDim: 64
- *   }
- * });
- *
- * await wrapper.initialize();
- *
- * // 4x faster with 75% memory reduction!
- * const results = await wrapper.attentionSearch(query, candidates, 'flash');
- * ```
- *
- * @example GNN Query Refinement
- * ```typescript
- * const wrapper = new EnhancedAgentDBWrapper({
- *   dimension: 768,
- *   enableGNN: true,
- *   gnnConfig: {
- *     numLayers: 3,
- *     hiddenDim: 256,
- *     numHeads: 8
- *   }
- * });
- *
- * // +12.4% recall improvement!
- * const results = await wrapper.gnnEnhancedSearch(query, {
- *   k: 10,
- *   graphContext: agentMemoryGraph
- * });
- * ```
- */
-export class EnhancedAgentDBWrapper {
-    agentDB;
-    config;
-    initialized = false;
-    dimension;
-    namespace;
-    reflexionController;
-    embedder;
-    vectorBackend;
-    attentionService;
-    gnnService;
-    // Performance tracking
-    metrics = {
-        attentionCalls: 0,
-        gnnCalls: 0,
-        totalAttentionTime: 0,
-        totalGNNTime: 0,
-        averageSpeedup: 0,
-        averageRecallImprovement: 0,
-    };
-    // For testing - allow dependency injection
-    _agentDB;
-    _embedder;
-    _vectorBackend;
-    _attentionService;
-    _gnnService;
-    constructor(config = {}) {
-        this.config = {
-            dbPath: config.dbPath || ':memory:',
-            namespace: config.namespace || 'default',
-            dimension: config.dimension || 384,
-            hnswConfig: {
-                M: config.hnswConfig?.M || 16,
-                efConstruction: config.hnswConfig?.efConstruction || 200,
-                efSearch: config.hnswConfig?.efSearch || 100,
-            },
-            enableAttention: config.enableAttention || false,
-            attentionConfig: {
-                type: config.attentionConfig?.type || 'flash',
-                numHeads: config.attentionConfig?.numHeads || 8,
-                headDim: config.attentionConfig?.headDim || 64,
-                embedDim: config.attentionConfig?.embedDim || config.dimension || 384,
-                dropout: config.attentionConfig?.dropout || 0.1,
-                curvature: config.attentionConfig?.curvature,
-                numExperts: config.attentionConfig?.numExperts || 8,
-                topK: config.attentionConfig?.topK || 2,
-            },
-            enableGNN: config.enableGNN || false,
-            gnnConfig: {
-                enabled: config.gnnConfig?.enabled || false,
-                inputDim: config.gnnConfig?.inputDim || config.dimension || 384,
-                hiddenDim: config.gnnConfig?.hiddenDim || 256,
-                numLayers: config.gnnConfig?.numLayers || 3,
-                numHeads: config.gnnConfig?.numHeads || 8,
-                aggregation: config.gnnConfig?.aggregation || 'attention',
-            },
-            autoInit: config.autoInit !== false,
-        };
-        this.dimension = this.config.dimension;
-        this.namespace = this.config.namespace;
-        if (this.config.autoInit) {
-            this.initialize().catch((err) => {
-                console.error('❌ Auto-initialization failed:', err);
-            });
-        }
-    }
-    /**
-     * Initialize AgentDB, AttentionService, and GNNService
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        try {
-            console.log('🚀 Initializing Enhanced AgentDB with advanced features...');
-            // 1. Initialize AgentDB
-            if (this._agentDB) {
-                this.agentDB = this._agentDB;
-                this.embedder = this._embedder;
-                this.vectorBackend = this._vectorBackend;
-            }
-            else {
-                this.agentDB = new AgentDB({
-                    dbPath: this.config.dbPath,
-                    namespace: this.namespace,
-                    enableAttention: this.config.enableAttention,
-                    attentionConfig: this.config.attentionConfig,
-                });
-                await this.agentDB.initialize();
-                this.reflexionController = this.agentDB.getController('reflexion');
-                this.embedder = this.reflexionController?.embedder;
-                this.vectorBackend = this.reflexionController?.vectorBackend;
-            }
-            // 2. Initialize AttentionService if enabled
-            if (this.config.enableAttention) {
-                await this.initializeAttentionService();
-            }
-            // 3. Initialize GNNService if enabled
-            if (this.config.enableGNN) {
-                await this.initializeGNNService();
-            }
-            // 4. Initialize embedder
-            if (this.embedder && this.embedder.initialize) {
-                await this.embedder.initialize();
-            }
-            this.initialized = true;
-            this.logInitializationSummary();
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize Enhanced AgentDB: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Initialize AttentionService with runtime detection
-     */
-    async initializeAttentionService() {
-        try {
-            if (this._attentionService) {
-                this.attentionService = this._attentionService;
-            }
-            else {
-                // Try to import AttentionService from agentdb package
-                // Note: AttentionService may not be available in all agentdb versions
-                try {
-                    // Use indirect dynamic import to avoid TypeScript module resolution errors
-                    const modulePath = 'agentdb/controllers/AttentionService';
-                    const attentionModule = await import(/* webpackIgnore: true */ modulePath).catch(() => null);
-                    if (attentionModule?.AttentionService) {
-                        this.attentionService = new attentionModule.AttentionService({
-                            numHeads: this.config.attentionConfig?.numHeads || 8,
-                            headDim: this.config.attentionConfig?.headDim || 64,
-                            embedDim: this.config.attentionConfig?.embedDim || this.dimension,
-                            dropout: this.config.attentionConfig?.dropout || 0.1,
-                        });
-                        await this.attentionService.initialize();
-                    }
-                }
-                catch {
-                    // AttentionService not available, will continue without it
-                }
-            }
-            const runtime = this.attentionService.runtime || 'js';
-            console.log(`  ✅ AttentionService initialized (runtime: ${runtime})`);
-            if (runtime === 'napi') {
-                console.log(`  ⚡ NAPI detected: 3x speedup available`);
-            }
-            else if (runtime === 'wasm') {
-                console.log(`  ⚡ WASM detected: 1.5x speedup available`);
-            }
-        }
-        catch (error) {
-            console.warn(`  ⚠️  AttentionService initialization failed: ${error}`);
-            console.warn(`  ⚠️  Continuing without attention features`);
-            this.config.enableAttention = false;
-        }
-    }
-    /**
-     * Initialize GNNService for query refinement
-     */
-    async initializeGNNService() {
-        try {
-            if (this._gnnService) {
-                this.gnnService = this._gnnService;
-            }
-            else {
-                // Import GNN from @ruvector/gnn
-                // Note: Uses RuvectorLayer as GraphNeuralNetwork is not exported
-                const gnnModule = await import('@ruvector/gnn');
-                // Create GNN layers using RuvectorLayer
-                const layers = [];
-                for (let i = 0; i < (this.config.gnnConfig?.numLayers || 3); i++) {
-                    const layer = new gnnModule.RuvectorLayer(i === 0 ? this.dimension : (this.config.gnnConfig?.hiddenDim || 256), this.config.gnnConfig?.hiddenDim || 256, this.config.gnnConfig?.numHeads || 8, 0.1 // dropout rate
-                    );
-                    layers.push(layer);
-                }
-                // Use hierarchicalForward for GNN operations
-                this.gnnService = {
-                    layers,
-                    forward: (query, embeddings) => {
-                        return gnnModule.hierarchicalForward(query, [embeddings], layers.map((l) => JSON.stringify(l)));
-                    }
-                };
-            }
-            console.log(`  ✅ GNN Service initialized (+12.4% recall target)`);
-        }
-        catch (error) {
-            console.warn(`  ⚠️  GNN Service initialization failed: ${error}`);
-            console.warn(`  ⚠️  Continuing without GNN features`);
-            this.config.enableGNN = false;
-        }
-    }
-    /**
-     * Log initialization summary
-     */
-    logInitializationSummary() {
-        console.log('');
-        console.log('✅ Enhanced AgentDB Initialized');
-        console.log(`  📊 Dimension: ${this.dimension}`);
-        console.log(`  🔍 HNSW: M=${this.config.hnswConfig?.M}, ef=${this.config.hnswConfig?.efSearch}`);
-        if (this.config.enableAttention) {
-            const type = this.config.attentionConfig?.type || 'flash';
-            console.log(`  🧠 Attention: ${type} (${this.config.attentionConfig?.numHeads} heads)`);
-        }
-        if (this.config.enableGNN) {
-            console.log(`  🕸️  GNN: ${this.config.gnnConfig?.numLayers} layers, ${this.config.gnnConfig?.hiddenDim} hidden`);
-        }
-        console.log('');
-    }
-    /**
-     * Ensure wrapper is initialized
-     */
-    ensureInitialized() {
-        if (!this.initialized) {
-            throw new Error('EnhancedAgentDBWrapper not initialized. Call initialize() first.');
-        }
-    }
-    /**
-     * Validate vector dimension
-     */
-    validateVectorDimension(vector) {
-        if (vector.length !== this.dimension) {
-            throw new Error(`Invalid vector dimension: expected ${this.dimension}, got ${vector.length}`);
-        }
-    }
-    /**
-     * Generate unique ID
-     */
-    generateId() {
-        return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    }
-    // ============================================
-    // BASIC OPERATIONS (from original wrapper)
-    // ============================================
-    async insert(options) {
-        this.ensureInitialized();
-        this.validateVectorDimension(options.vector);
-        const id = options.id || this.generateId();
-        const timestamp = Date.now();
-        const metadata = {
-            ...options.metadata,
-            timestamp,
-            namespace: options.namespace || this.namespace,
-        };
-        const controller = this._agentDB ? this._agentDB.getController('reflexion') : this.reflexionController;
-        await controller.store({
-            id,
-            vector: options.vector,
-            metadata,
-        });
-        return { id, timestamp };
-    }
-    async vectorSearch(query, options = {}) {
-        this.ensureInitialized();
-        this.validateVectorDimension(query);
-        const { k = 10, metric = 'cosine', filter, includeVectors = false, hnswParams } = options;
-        const controller = this._agentDB ? this._agentDB.getController('reflexion') : this.reflexionController;
-        const results = await controller.retrieve(query, {
-            k,
-            metric,
-            filter,
-            includeVectors,
-            hnswParams,
-        });
-        return results.map((result) => ({
-            id: result.id,
-            score: result.score,
-            metadata: result.metadata,
-            ...(includeVectors && { vector: result.vector }),
-        }));
-    }
-    async update(options) {
-        this.ensureInitialized();
-        if (options.vector) {
-            this.validateVectorDimension(options.vector);
-        }
-        const controller = this._agentDB ? this._agentDB.getController('reflexion') : this.reflexionController;
-        const updateData = {};
-        if (options.vector)
-            updateData.vector = options.vector;
-        if (options.metadata)
-            updateData.metadata = options.metadata;
-        const result = await controller.update(options.id, updateData);
-        if (!result) {
-            throw new Error(`Vector not found: ${options.id}`);
-        }
-        return result;
-    }
-    async delete(options) {
-        this.ensureInitialized();
-        const controller = this._agentDB ? this._agentDB.getController('reflexion') : this.reflexionController;
-        return await controller.delete(options.id);
-    }
-    async get(options) {
-        this.ensureInitialized();
-        const controller = this._agentDB ? this._agentDB.getController('reflexion') : this.reflexionController;
-        const result = await controller.get(options.id);
-        if (!result)
-            return null;
-        const entry = {
-            id: result.id,
-            vector: result.vector,
-            metadata: result.metadata,
-        };
-        if (options.includeVector === false) {
-            delete entry.vector;
-        }
-        return entry;
-    }
-    async batchInsert(entries) {
-        this.ensureInitialized();
-        const startTime = Date.now();
-        const result = {
-            inserted: 0,
-            failed: [],
-            duration: 0,
-        };
-        for (let i = 0; i < entries.length; i++) {
-            try {
-                await this.insert(entries[i]);
-                result.inserted++;
-            }
-            catch (error) {
-                result.failed.push({
-                    index: i,
-                    id: entries[i].id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        result.duration = Date.now() - startTime;
-        return result;
-    }
-    async getStats() {
-        this.ensureInitialized();
-        const backend = this._vectorBackend || this.vectorBackend;
-        const stats = await backend.getStats();
-        return {
-            vectorCount: stats.vectorCount || 0,
-            dimension: this.dimension,
-            databaseSize: stats.databaseSize || 0,
-            hnswStats: stats.hnswStats,
-            memoryUsage: stats.memoryUsage,
-            indexBuildTime: stats.indexBuildTime,
-        };
-    }
-    async close() {
-        if (!this.initialized)
-            return;
-        const db = this._agentDB || this.agentDB;
-        await db.close();
-        this.initialized = false;
-    }
-    getRawInstance() {
-        this.ensureInitialized();
-        return this.agentDB;
-    }
-    // ============================================
-    // ADVANCED FEATURES: ATTENTION MECHANISMS
-    // ============================================
-    /**
-     * Attention-based search with configurable mechanism
-     *
-     * @param query - Query vector
-     * @param candidates - Pre-retrieved candidates from HNSW
-     * @param mechanism - Attention type to use
-     * @returns AttentionResult with performance metrics
-     *
-     * @example Flash Attention (4x faster)
-     * ```typescript
-     * const result = await wrapper.attentionSearch(query, candidates, 'flash');
-     * console.log(`Speedup: ${result.mechanism}, Time: ${result.executionTimeMs}ms`);
-     * ```
-     */
-    async attentionSearch(query, candidates, mechanism = 'flash') {
-        this.ensureInitialized();
-        if (!this.config.enableAttention || !this.attentionService) {
-            throw new Error('Attention not enabled. Set enableAttention: true in config.');
-        }
-        this.validateVectorDimension(query);
-        const startTime = Date.now();
-        // Prepare Q, K, V tensors
-        const Q = query;
-        const K = this.stackVectors(candidates.map((c) => c.vector));
-        const V = K; // Self-attention over candidates
-        let result;
-        // Route to appropriate attention mechanism
-        switch (mechanism) {
-            case 'flash':
-                result = await this.attentionService.flashAttention(Q, K, V);
-                break;
-            case 'multi-head':
-                result = await this.attentionService.multiHeadAttention(Q, K, V);
-                break;
-            case 'linear':
-                result = await this.attentionService.linearAttention(Q, K, V);
-                break;
-            case 'hyperbolic':
-                result = await this.attentionService.hyperbolicAttention(Q, K, V, this.config.attentionConfig?.curvature || -1.0);
-                break;
-            case 'moe':
-                result = await this.attentionService.moeAttention(Q, K, V, this.config.attentionConfig?.numExperts || 8);
-                break;
-            case 'graph-rope':
-                // GraphRoPE requires graph structure
-                throw new Error('Use graphRoPEAttention() for graph-rope mechanism');
-            default:
-                throw new Error(`Unknown attention mechanism: ${mechanism}`);
-        }
-        const executionTimeMs = Date.now() - startTime;
-        // Track metrics
-        this.metrics.attentionCalls++;
-        this.metrics.totalAttentionTime += executionTimeMs;
-        return {
-            output: result.output,
-            mechanism,
-            runtime: this.attentionService.runtime || 'js',
-            executionTimeMs,
-            attentionWeights: result.attentionWeights,
-            memoryUsage: result.memoryUsage,
-        };
-    }
-    /**
-     * Multi-Head Attention (Standard Transformer)
-     *
-     * Complexity: O(n²)
-     * Best for: General-purpose attention, standard retrieval
-     * Performance: ~15ms P50 for 512 tokens
-     */
-    async multiHeadAttention(Q, K, V) {
-        return await this.attentionSearch(Q, this.unstackVectors(K), 'multi-head');
-    }
-    /**
-     * Flash Attention (Memory-Efficient)
-     *
-     * Complexity: O(n²) with O(n) memory
-     * Best for: Long sequences, memory-constrained environments
-     * Performance: ~3ms P50 for 512 tokens (4x faster than multi-head!)
-     * Memory: 75% reduction
-     */
-    async flashAttention(Q, K, V) {
-        return await this.attentionSearch(Q, this.unstackVectors(K), 'flash');
-    }
-    /**
-     * Linear Attention (O(N) Complexity)
-     *
-     * Complexity: O(n)
-     * Best for: Very long sequences (>2048 tokens)
-     * Performance: ~18ms P50 for 2048 tokens
-     */
-    async linearAttention(Q, K, V) {
-        return await this.attentionSearch(Q, this.unstackVectors(K), 'linear');
-    }
-    /**
-     * Hyperbolic Attention (Hierarchical Reasoning)
-     *
-     * Complexity: O(n²) in hyperbolic space
-     * Best for: Tree-structured data, agent hierarchies
-     * Performance: ~8ms P50 for 512 tokens
-     */
-    async hyperbolicAttention(Q, K, V, curvature = -1.0) {
-        const oldCurvature = this.config.attentionConfig?.curvature;
-        this.config.attentionConfig.curvature = curvature;
-        const result = await this.attentionSearch(Q, this.unstackVectors(K), 'hyperbolic');
-        this.config.attentionConfig.curvature = oldCurvature;
-        return result;
-    }
-    /**
-     * Mixture-of-Experts (MoE) Attention
-     *
-     * Complexity: Sparse O(n²)
-     * Best for: Multi-agent systems with specialized agents
-     * Performance: ~20ms P50 for 512 tokens
-     */
-    async moeAttention(Q, K, V, numExperts = 8) {
-        const oldExperts = this.config.attentionConfig?.numExperts;
-        this.config.attentionConfig.numExperts = numExperts;
-        const result = await this.attentionSearch(Q, this.unstackVectors(K), 'moe');
-        this.config.attentionConfig.numExperts = oldExperts;
-        return result;
-    }
-    /**
-     * GraphRoPE Attention (Graph-aware Position Embeddings)
-     *
-     * Complexity: O(n²) with graph structure
-     * Best for: Multi-agent coordination with topology awareness
-     * Use case: Mesh, hierarchical, ring topologies
-     */
-    async graphRoPEAttention(Q, K, V, graphStructure) {
-        this.ensureInitialized();
-        if (!this.config.enableAttention || !this.attentionService) {
-            throw new Error('Attention not enabled.');
-        }
-        const startTime = Date.now();
-        const result = await this.attentionService.graphRoPEAttention(Q, K, V, graphStructure);
-        const executionTimeMs = Date.now() - startTime;
-        this.metrics.attentionCalls++;
-        this.metrics.totalAttentionTime += executionTimeMs;
-        return {
-            output: result.output,
-            mechanism: 'graph-rope',
-            runtime: this.attentionService.runtime || 'js',
-            executionTimeMs,
-            attentionWeights: result.attentionWeights,
-            memoryUsage: result.memoryUsage,
-        };
-    }
-    // ============================================
-    // ADVANCED FEATURES: GNN QUERY REFINEMENT
-    // ============================================
-    /**
-     * GNN-enhanced search with +12.4% recall improvement
-     *
-     * @param query - Query vector
-     * @param options - Advanced search options with graph context
-     * @returns GNN refinement result with performance metrics
-     *
-     * @example
-     * ```typescript
-     * const result = await wrapper.gnnEnhancedSearch(query, {
-     *   k: 10,
-     *   graphContext: { nodes, edges }
-     * });
-     * console.log(`Recall improvement: +${result.improvementPercent}%`);
-     * ```
-     */
-    async gnnEnhancedSearch(query, options) {
-        this.ensureInitialized();
-        if (!this.config.enableGNN || !this.gnnService) {
-            throw new Error('GNN not enabled. Set enableGNN: true in config.');
-        }
-        const startTime = Date.now();
-        // 1. Initial HNSW retrieval (baseline)
-        const baselineResults = await this.vectorSearch(query, options);
-        const baselineRecall = this.calculateRecall(baselineResults);
-        // 2. GNN query refinement
-        let refinedQuery = query;
-        if (options.graphContext) {
-            refinedQuery = await this.gnnService.forward(query, options.graphContext);
-        }
-        // 3. Re-search with refined query
-        const refinedResults = await this.vectorSearch(refinedQuery, options);
-        // 4. GNN-based re-ranking
-        let finalResults = refinedResults;
-        if (options.graphContext) {
-            finalResults = await this.gnnRerank(refinedResults, options.graphContext);
-        }
-        const improvedRecall = this.calculateRecall(finalResults);
-        const improvementPercent = ((improvedRecall - baselineRecall) / baselineRecall) * 100;
-        const executionTimeMs = Date.now() - startTime;
-        // Track metrics
-        this.metrics.gnnCalls++;
-        this.metrics.totalGNNTime += executionTimeMs;
-        this.metrics.averageRecallImprovement =
-            (this.metrics.averageRecallImprovement * (this.metrics.gnnCalls - 1) + improvementPercent) /
-                this.metrics.gnnCalls;
-        return {
-            results: finalResults,
-            originalRecall: baselineRecall,
-            improvedRecall,
-            improvementPercent,
-            executionTimeMs,
-        };
-    }
-    /**
-     * GNN-based re-ranking of candidates
-     */
-    async gnnRerank(candidates, graphContext) {
-        // Extract candidate vectors
-        const candidateVectors = candidates.map((c) => c.vector);
-        // Build graph for candidates
-        const candidateGraph = {
-            nodes: candidateVectors,
-            edges: this.buildCandidateGraph(candidateVectors),
-        };
-        // GNN forward pass
-        const gnnScores = await this.gnnService.forward(candidateVectors[0], candidateGraph);
-        // Re-rank based on GNN scores
-        return candidates
-            .map((candidate, i) => ({
-            ...candidate,
-            score: candidate.score * (1 + gnnScores[i] * 0.1), // Blend original + GNN
-        }))
-            .sort((a, b) => b.score - a.score);
-    }
-    /**
-     * Build graph edges between candidates based on similarity
-     */
-    buildCandidateGraph(vectors) {
-        const edges = [];
-        const k = 5; // Connect to 5 nearest neighbors
-        for (let i = 0; i < vectors.length; i++) {
-            const similarities = vectors.map((v, j) => ({
-                index: j,
-                similarity: this.cosineSimilarity(vectors[i], v),
-            }));
-            similarities.sort((a, b) => b.similarity - a.similarity);
-            for (let j = 1; j <= k && j < similarities.length; j++) {
-                edges.push([i, similarities[j].index]);
-            }
-        }
-        return edges;
-    }
-    // ============================================
-    // UTILITY FUNCTIONS
-    // ============================================
-    /**
-     * Stack multiple vectors into single tensor
-     */
-    stackVectors(vectors) {
-        const total = vectors.reduce((sum, v) => sum + v.length, 0);
-        const stacked = new Float32Array(total);
-        let offset = 0;
-        for (const v of vectors) {
-            stacked.set(v, offset);
-            offset += v.length;
-        }
-        return stacked;
-    }
-    /**
-     * Unstack tensor into individual vectors
-     */
-    unstackVectors(tensor) {
-        const results = [];
-        const numVectors = tensor.length / this.dimension;
-        for (let i = 0; i < numVectors; i++) {
-            const vector = tensor.slice(i * this.dimension, (i + 1) * this.dimension);
-            results.push({
-                id: `vec-${i}`,
-                score: 1.0,
-                vector,
-            });
-        }
-        return results;
-    }
-    /**
-     * Calculate recall@k metric
-     */
-    calculateRecall(results) {
-        // Simplified recall calculation (in real use, need ground truth)
-        return results.length > 0 ? results[0].score : 0;
-    }
-    /**
-     * Calculate cosine similarity
-     */
-    cosineSimilarity(a, b) {
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-    }
-    /**
-     * Get performance metrics
-     */
-    getPerformanceMetrics() {
-        return {
-            ...this.metrics,
-            averageAttentionTime: this.metrics.attentionCalls > 0 ? this.metrics.totalAttentionTime / this.metrics.attentionCalls : 0,
-            averageGNNTime: this.metrics.gnnCalls > 0 ? this.metrics.totalGNNTime / this.metrics.gnnCalls : 0,
-        };
-    }
-    /**
-     * Get attention service for direct access
-     */
-    getAttentionService() {
-        return this.attentionService;
-    }
-    /**
-     * Get GNN service for direct access
-     */
-    getGNNService() {
-        return this.gnnService;
-    }
-}
-//# sourceMappingURL=agentdb-wrapper-enhanced.js.map