agentic-flow 1.9.4 → 1.10.1

package/dist/utils/connection-pool.js

@@ -0,0 +1,184 @@
+/**
+ * Connection Pool for HTTP/2 and HTTP/3 Proxies
+ * Provides connection reuse to reduce latency by 20-30%
+ */
+import http2 from 'http2';
+import { logger } from './logger.js';
+export class ConnectionPool {
+    pools = new Map();
+    config;
+    cleanupInterval;
+    constructor(config = {}) {
+        this.config = {
+            maxSize: config.maxSize || 10,
+            maxIdleTime: config.maxIdleTime || 60000, // 60 seconds
+            acquireTimeout: config.acquireTimeout || 5000 // 5 seconds
+        };
+        // Cleanup expired connections every 30 seconds
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, 30000);
+    }
+    async acquire(host) {
+        const pool = this.pools.get(host) || [];
+        const now = Date.now();
+        // Find idle, non-expired connection
+        const idle = pool.find(c => !c.busy &&
+            !this.isExpired(c, now) &&
+            !c.session.closed &&
+            !c.session.destroyed);
+        if (idle) {
+            idle.busy = true;
+            idle.lastUsed = now;
+            logger.debug('Reusing pooled connection', { host, poolSize: pool.length });
+            return idle.session;
+        }
+        // Create new if under limit
+        if (pool.length < this.config.maxSize) {
+            const session = await this.createConnection(host);
+            const conn = {
+                session,
+                host,
+                busy: true,
+                createdAt: now,
+                lastUsed: now
+            };
+            pool.push(conn);
+            this.pools.set(host, pool);
+            logger.debug('Created new pooled connection', {
+                host,
+                poolSize: pool.length,
+                maxSize: this.config.maxSize
+            });
+            return session;
+        }
+        // Wait for available connection
+        logger.debug('Pool full, waiting for connection', { host, poolSize: pool.length });
+        return this.waitForConnection(host);
+    }
+    async release(session, host) {
+        const pool = this.pools.get(host);
+        if (!pool)
+            return;
+        const conn = pool.find(c => c.session === session);
+        if (conn) {
+            conn.busy = false;
+            conn.lastUsed = Date.now();
+            logger.debug('Released pooled connection', { host });
+        }
+    }
+    async createConnection(host) {
+        return new Promise((resolve, reject) => {
+            const session = http2.connect(host, {
+                maxSessionMemory: 10 // 10MB per session
+            });
+            session.once('connect', () => {
+                logger.info('HTTP/2 session connected', { host });
+                resolve(session);
+            });
+            session.once('error', (error) => {
+                logger.error('HTTP/2 session error', { host, error: error.message });
+                reject(error);
+            });
+            // Cleanup on session close
+            session.once('close', () => {
+                this.removeConnection(session, host);
+            });
+        });
+    }
+    async waitForConnection(host) {
+        const startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            const checkInterval = setInterval(() => {
+                const pool = this.pools.get(host);
+                if (!pool) {
+                    clearInterval(checkInterval);
+                    reject(new Error('Pool disappeared'));
+                    return;
+                }
+                const now = Date.now();
+                const available = pool.find(c => !c.busy &&
+                    !this.isExpired(c, now) &&
+                    !c.session.closed);
+                if (available) {
+                    clearInterval(checkInterval);
+                    available.busy = true;
+                    available.lastUsed = now;
+                    resolve(available.session);
+                    return;
+                }
+                if (now - startTime > this.config.acquireTimeout) {
+                    clearInterval(checkInterval);
+                    reject(new Error('Connection acquire timeout'));
+                }
+            }, 100); // Check every 100ms
+        });
+    }
+    isExpired(conn, now) {
+        return (now - conn.lastUsed) > this.config.maxIdleTime;
+    }
+    removeConnection(session, host) {
+        const pool = this.pools.get(host);
+        if (!pool)
+            return;
+        const index = pool.findIndex(c => c.session === session);
+        if (index !== -1) {
+            pool.splice(index, 1);
+            logger.debug('Removed closed connection from pool', { host, poolSize: pool.length });
+        }
+        if (pool.length === 0) {
+            this.pools.delete(host);
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        let removed = 0;
+        for (const [host, pool] of this.pools.entries()) {
+            const before = pool.length;
+            // Remove expired and closed connections
+            const active = pool.filter(c => {
+                if (this.isExpired(c, now) || c.session.closed || c.session.destroyed) {
+                    if (!c.session.closed) {
+                        c.session.close();
+                    }
+                    return false;
+                }
+                return true;
+            });
+            removed += before - active.length;
+            if (active.length === 0) {
+                this.pools.delete(host);
+            }
+            else {
+                this.pools.set(host, active);
+            }
+        }
+        if (removed > 0) {
+            logger.debug('Cleaned up expired connections', { removed });
+        }
+    }
+    destroy() {
+        clearInterval(this.cleanupInterval);
+        for (const [host, pool] of this.pools.entries()) {
+            for (const conn of pool) {
+                if (!conn.session.closed) {
+                    conn.session.close();
+                }
+            }
+        }
+        this.pools.clear();
+        logger.info('Connection pool destroyed');
+    }
+    getStats() {
+        const stats = {};
+        for (const [host, pool] of this.pools.entries()) {
+            const busy = pool.filter(c => c.busy).length;
+            stats[host] = {
+                total: pool.length,
+                busy,
+                idle: pool.length - busy
+            };
+        }
+        return stats;
+    }
+}

package/dist/utils/dynamic-compression.js

@@ -0,0 +1,298 @@
+/**
+ * Dynamic Compression based on CPU
+ * Adaptive compression levels based on CPU availability
+ * Phase 3 Optimization
+ */
+import * as zlib from 'zlib';
+import { performance } from 'perf_hooks';
+/**
+ * Compression levels with CPU costs
+ */
+export const COMPRESSION_LEVELS = {
+    gzip: [
+        { level: 1, name: 'fastest', cpuCost: 1, compressionRatio: 3 },
+        { level: 3, name: 'fast', cpuCost: 3, compressionRatio: 5 },
+        { level: 6, name: 'default', cpuCost: 6, compressionRatio: 7 },
+        { level: 9, name: 'best', cpuCost: 10, compressionRatio: 9 }
+    ],
+    brotli: [
+        { level: 1, name: 'fastest', cpuCost: 2, compressionRatio: 4 },
+        { level: 4, name: 'fast', cpuCost: 4, compressionRatio: 6 },
+        { level: 6, name: 'default', cpuCost: 7, compressionRatio: 8 },
+        { level: 11, name: 'best', cpuCost: 10, compressionRatio: 10 }
+    ]
+};
+/**
+ * Dynamic Compression Manager
+ * Adjusts compression levels based on CPU load
+ */
+export class DynamicCompressionManager {
+    config;
+    stats;
+    currentLevelIndex = 1; // Start with 'fast'
+    cpuSamples = [];
+    monitorInterval;
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            minSize: config.minSize || 1024,
+            algorithm: config.algorithm || 'gzip',
+            adaptive: config.adaptive !== false,
+            cpuThresholdHigh: config.cpuThresholdHigh || 70,
+            cpuThresholdLow: config.cpuThresholdLow || 30,
+            checkInterval: config.checkInterval || 5000
+        };
+        this.stats = {
+            totalBytes: 0,
+            compressedBytes: 0,
+            compressionRatio: 1,
+            avgCompressionTime: 0,
+            currentLevel: this.getCurrentLevel().level,
+            levelChanges: 0,
+            cpuAdjustments: 0
+        };
+        if (this.config.adaptive) {
+            this.startCPUMonitoring();
+        }
+    }
+    /**
+     * Compress data with adaptive level
+     */
+    async compress(data) {
+        if (!this.config.enabled || data.length < this.config.minSize) {
+            return data;
+        }
+        const startTime = performance.now();
+        const level = this.getCurrentLevel();
+        let compressed;
+        try {
+            if (this.config.algorithm === 'brotli') {
+                compressed = await this.compressBrotli(data, level.level);
+            }
+            else if (this.config.algorithm === 'deflate') {
+                compressed = await this.compressDeflate(data, level.level);
+            }
+            else {
+                compressed = await this.compressGzip(data, level.level);
+            }
+            // Update statistics
+            const compressionTime = performance.now() - startTime;
+            this.updateStats(data.length, compressed.length, compressionTime);
+            return compressed;
+        }
+        catch (error) {
+            // Fallback to uncompressed
+            return data;
+        }
+    }
+    /**
+     * Compress with gzip
+     */
+    compressGzip(data, level) {
+        return new Promise((resolve, reject) => {
+            zlib.gzip(data, { level }, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    /**
+     * Compress with brotli
+     */
+    compressBrotli(data, level) {
+        return new Promise((resolve, reject) => {
+            zlib.brotliCompress(data, {
+                params: {
+                    [zlib.constants.BROTLI_PARAM_QUALITY]: level
+                }
+            }, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    /**
+     * Compress with deflate
+     */
+    compressDeflate(data, level) {
+        return new Promise((resolve, reject) => {
+            zlib.deflate(data, { level }, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    /**
+     * Get current compression level
+     */
+    getCurrentLevel() {
+        const levels = COMPRESSION_LEVELS[this.config.algorithm];
+        return levels[this.currentLevelIndex] || levels[1];
+    }
+    /**
+     * Adjust compression level based on CPU
+     */
+    adjustLevel(cpuUsage) {
+        const levels = COMPRESSION_LEVELS[this.config.algorithm];
+        const oldIndex = this.currentLevelIndex;
+        if (cpuUsage > this.config.cpuThresholdHigh && this.currentLevelIndex > 0) {
+            // CPU high, reduce compression level
+            this.currentLevelIndex--;
+            this.stats.cpuAdjustments++;
+        }
+        else if (cpuUsage < this.config.cpuThresholdLow && this.currentLevelIndex < levels.length - 1) {
+            // CPU low, increase compression level
+            this.currentLevelIndex++;
+            this.stats.cpuAdjustments++;
+        }
+        if (oldIndex !== this.currentLevelIndex) {
+            this.stats.levelChanges++;
+            this.stats.currentLevel = this.getCurrentLevel().level;
+        }
+    }
+    /**
+     * Start CPU monitoring
+     */
+    startCPUMonitoring() {
+        this.monitorInterval = setInterval(() => {
+            const cpuUsage = this.getCPUUsage();
+            this.cpuSamples.push(cpuUsage);
+            // Keep last 10 samples
+            if (this.cpuSamples.length > 10) {
+                this.cpuSamples.shift();
+            }
+            // Calculate average CPU
+            const avgCPU = this.cpuSamples.reduce((a, b) => a + b, 0) / this.cpuSamples.length;
+            // Adjust compression level
+            this.adjustLevel(avgCPU);
+        }, this.config.checkInterval);
+    }
+    /**
+     * Get CPU usage percentage
+     */
+    getCPUUsage() {
+        const cpus = require('os').cpus();
+        let totalIdle = 0;
+        let totalTick = 0;
+        for (const cpu of cpus) {
+            for (const type in cpu.times) {
+                totalTick += cpu.times[type];
+            }
+            totalIdle += cpu.times.idle;
+        }
+        const idle = totalIdle / cpus.length;
+        const total = totalTick / cpus.length;
+        const usage = 100 - ~~(100 * idle / total);
+        return Math.max(0, Math.min(100, usage));
+    }
+    /**
+     * Update statistics
+     */
+    updateStats(originalSize, compressedSize, time) {
+        this.stats.totalBytes += originalSize;
+        this.stats.compressedBytes += compressedSize;
+        this.stats.compressionRatio = this.stats.totalBytes / this.stats.compressedBytes;
+        // Update average compression time
+        const totalCompressions = this.stats.totalBytes / (originalSize || 1);
+        this.stats.avgCompressionTime =
+            (this.stats.avgCompressionTime * (totalCompressions - 1) + time) / totalCompressions;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const level = this.getCurrentLevel();
+        const avgCPU = this.cpuSamples.length > 0
+            ? this.cpuSamples.reduce((a, b) => a + b, 0) / this.cpuSamples.length
+            : 0;
+        return {
+            ...this.stats,
+            currentLevelName: level.name,
+            cpuUsage: avgCPU
+        };
+    }
+    /**
+     * Get compression savings
+     */
+    getSavings() {
+        const byteSavings = this.stats.totalBytes - this.stats.compressedBytes;
+        const percentSavings = (byteSavings / this.stats.totalBytes) * 100;
+        const mbSaved = byteSavings / (1024 * 1024);
+        return {
+            byteSavings,
+            percentSavings,
+            mbSaved
+        };
+    }
+    /**
+     * Manually set compression level
+     */
+    setLevel(levelName) {
+        const levels = COMPRESSION_LEVELS[this.config.algorithm];
+        const index = levels.findIndex(l => l.name === levelName);
+        if (index !== -1) {
+            this.currentLevelIndex = index;
+            this.stats.currentLevel = levels[index].level;
+            this.stats.levelChanges++;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalBytes: 0,
+            compressedBytes: 0,
+            compressionRatio: 1,
+            avgCompressionTime: 0,
+            currentLevel: this.getCurrentLevel().level,
+            levelChanges: 0,
+            cpuAdjustments: 0
+        };
+    }
+    /**
+     * Stop CPU monitoring
+     */
+    destroy() {
+        if (this.monitorInterval) {
+            clearInterval(this.monitorInterval);
+        }
+    }
+}
+/**
+ * Content-type aware compression
+ */
+export function shouldCompress(contentType, size, minSize = 1024) {
+    if (size < minSize) {
+        return false;
+    }
+    const compressibleTypes = [
+        'text/',
+        'application/json',
+        'application/javascript',
+        'application/xml',
+        'application/x-www-form-urlencoded'
+    ];
+    return compressibleTypes.some(type => contentType.startsWith(type));
+}
+/**
+ * Calculate compression efficiency
+ */
+export function calculateCompressionEfficiency(stats) {
+    const timePerMB = stats.avgCompressionTime / ((stats.totalBytes / (1024 * 1024)) || 1);
+    const ratioScore = Math.min(100, (stats.compressionRatio - 1) * 10);
+    const efficiency = (ratioScore * 0.7) + ((100 - Math.min(100, timePerMB)) * 0.3);
+    return {
+        efficiency,
+        timePerMB,
+        ratioScore
+    };
+}