agentic-qe 1.9.3 → 2.0.0

package/dist/core/transport/QUICTransport.js

@@ -0,0 +1,711 @@
+"use strict";
+/**
+ * QUIC Transport Layer for AgentDB
+ * Provides low-latency, multiplexed connections with HTTP/2 fallback
+ *
+ * Since QUIC is experimental in Node.js, this implementation uses HTTP/2 as primary
+ * transport with the QUIC interface ready for future integration.
+ *
+ * Features:
+ * - Connection pooling with automatic scaling
+ * - Circuit breaker pattern for fault tolerance
+ * - Exponential backoff retry logic
+ * - Health monitoring and metrics
+ * - Automatic fallback from HTTP/2 to HTTP/1.1
+ * - Low-latency multiplexed streams
+ *
+ * @version 1.0.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUIC_CONFIG = exports.QUICTransport = exports.ConnectionPool = exports.CircuitBreaker = void 0;
+exports.createQUICTransport = createQUICTransport;
+const http2 = __importStar(require("http2"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const events_1 = require("events");
+/**
+ * Circuit Breaker Implementation
+ * Prevents cascading failures by stopping requests to unhealthy services
+ */
+class CircuitBreaker {
+    constructor(options) {
+        this.state = 'closed';
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.lastFailure = null;
+        this.nextRetryTime = null;
+        this.failureThreshold = options.failureThreshold;
+        this.successThreshold = options.successThreshold;
+        this.timeout = options.timeout;
+    }
+    /**
+     * Execute operation with circuit breaker protection
+     */
+    async execute(operation) {
+        // Check if circuit is open
+        if (this.state === 'open') {
+            const now = Date.now();
+            if (this.nextRetryTime && now < this.nextRetryTime.getTime()) {
+                throw new Error('Circuit breaker is OPEN - requests blocked');
+            }
+            // Try half-open state
+            this.state = 'half-open';
+            this.successCount = 0;
+        }
+        try {
+            const result = await operation();
+            this.recordSuccess();
+            return result;
+        }
+        catch (error) {
+            this.recordFailure();
+            throw error;
+        }
+    }
+    /**
+     * Record successful operation
+     */
+    recordSuccess() {
+        this.failureCount = 0;
+        if (this.state === 'half-open') {
+            this.successCount++;
+            if (this.successCount >= this.successThreshold) {
+                this.state = 'closed';
+                this.successCount = 0;
+            }
+        }
+    }
+    /**
+     * Record failed operation
+     */
+    recordFailure() {
+        this.failureCount++;
+        this.lastFailure = new Date();
+        if (this.failureCount >= this.failureThreshold) {
+            this.state = 'open';
+            this.nextRetryTime = new Date(Date.now() + this.timeout);
+        }
+    }
+    /**
+     * Get current circuit breaker state
+     */
+    getState() {
+        return {
+            state: this.state,
+            failureCount: this.failureCount,
+            successCount: this.successCount,
+            lastFailure: this.lastFailure,
+            nextRetryTime: this.nextRetryTime
+        };
+    }
+    /**
+     * Reset circuit breaker
+     */
+    reset() {
+        this.state = 'closed';
+        this.failureCount = 0;
+        this.successCount = 0;
+        this.lastFailure = null;
+        this.nextRetryTime = null;
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;
+/**
+ * Connection Pool Management
+ * Manages a pool of reusable connections
+ */
+class ConnectionPool {
+    constructor(options) {
+        this.connections = [];
+        this.cleanupInterval = null;
+        this.minSize = options.minSize;
+        this.maxSize = options.maxSize;
+        this.idleTimeout = options.idleTimeout;
+        // Start cleanup interval
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, 30000); // Clean up every 30 seconds
+    }
+    /**
+     * Acquire a connection from the pool
+     */
+    async acquire() {
+        // Try to find an available healthy connection
+        const available = this.connections.find(conn => conn.isHealthy && conn.streams.size < 100);
+        if (available) {
+            available.lastUsed = new Date();
+            available.requestCount++;
+            return available;
+        }
+        // Create new connection if pool not full
+        if (this.connections.length < this.maxSize) {
+            const conn = await this.createConnection();
+            this.connections.push(conn);
+            return conn;
+        }
+        // Pool is full, wait and retry
+        await this.sleep(100);
+        return this.acquire();
+    }
+    /**
+     * Release a connection back to the pool
+     */
+    release(conn) {
+        conn.lastUsed = new Date();
+    }
+    /**
+     * Mark connection as unhealthy
+     */
+    markUnhealthy(conn) {
+        conn.isHealthy = false;
+    }
+    /**
+     * Get pool statistics
+     */
+    getStats() {
+        const healthy = this.connections.filter(c => c.isHealthy).length;
+        return {
+            size: this.connections.length,
+            healthy,
+            utilization: this.connections.length / this.maxSize
+        };
+    }
+    /**
+     * Drain and close all connections
+     */
+    async drain() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        const closePromises = this.connections.map(conn => this.closeConnection(conn));
+        await Promise.all(closePromises);
+        this.connections = [];
+    }
+    /**
+     * Cleanup idle connections
+     */
+    cleanup() {
+        const now = Date.now();
+        const toRemove = [];
+        for (const conn of this.connections) {
+            const idle = now - conn.lastUsed.getTime();
+            if (idle > this.idleTimeout && this.connections.length > this.minSize) {
+                toRemove.push(conn);
+            }
+        }
+        // Remove idle connections
+        toRemove.forEach(conn => {
+            const index = this.connections.indexOf(conn);
+            if (index > -1) {
+                this.connections.splice(index, 1);
+                this.closeConnection(conn);
+            }
+        });
+    }
+    /**
+     * Create a new connection (placeholder - implemented in QUICTransport)
+     */
+    async createConnection() {
+        return {
+            id: `conn-${Date.now()}-${Math.random()}`,
+            session: new http.Agent({ keepAlive: true }),
+            endpoint: '',
+            protocol: 'http1',
+            createdAt: new Date(),
+            lastUsed: new Date(),
+            requestCount: 0,
+            isHealthy: true,
+            streams: new Set()
+        };
+    }
+    /**
+     * Close a connection
+     */
+    async closeConnection(conn) {
+        try {
+            if (conn.protocol === 'http2') {
+                // HTTP/2 session
+                if (conn.session && typeof conn.session.close === 'function') {
+                    conn.session.close();
+                }
+            }
+            else {
+                // HTTP/1.1 agent
+                if (conn.session && typeof conn.session.destroy === 'function') {
+                    conn.session.destroy();
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors during cleanup
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.ConnectionPool = ConnectionPool;
+/**
+ * QUIC Transport Layer
+ * Main transport implementation with HTTP/2 fallback
+ */
+class QUICTransport extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.pools = new Map();
+        this.requests = [];
+        this.latencyBuffer = [];
+        this.config = {
+            ...config,
+            poolSize: config.poolSize || { min: 2, max: 10 },
+            circuitBreaker: config.circuitBreaker || {
+                failureThreshold: 5,
+                successThreshold: 2,
+                timeout: 60000
+            }
+        };
+        this.circuitBreaker = new CircuitBreaker(this.config.circuitBreaker);
+        this.metrics = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            avgLatency: 0,
+            p50Latency: 0,
+            p95Latency: 0,
+            p99Latency: 0,
+            bytesSent: 0,
+            bytesReceived: 0,
+            circuitBreakerState: 'closed',
+            activeConnections: 0,
+            poolUtilization: 0
+        };
+    }
+    /**
+     * Connect to an endpoint
+     */
+    async connect(endpoint) {
+        const pool = this.getOrCreatePool(endpoint);
+        const conn = await pool.acquire();
+        // Create actual connection if needed
+        if (!conn.endpoint) {
+            const url = new URL(endpoint);
+            const protocol = await this.detectBestProtocol(url);
+            try {
+                if (protocol === 'http2') {
+                    conn.session = await this.createHTTP2Connection(url);
+                    conn.protocol = 'http2';
+                }
+                else {
+                    conn.session = this.createHTTP1Connection(url);
+                    conn.protocol = 'http1';
+                }
+                conn.endpoint = endpoint;
+            }
+            catch (error) {
+                pool.markUnhealthy(conn);
+                throw error;
+            }
+        }
+        return conn;
+    }
+    /**
+     * Disconnect from an endpoint
+     */
+    async disconnect(endpoint) {
+        const pool = this.pools.get(endpoint);
+        if (pool) {
+            await pool.drain();
+            this.pools.delete(endpoint);
+        }
+    }
+    /**
+     * Send data to endpoint
+     */
+    async send(endpoint, data) {
+        return this.withCircuitBreaker(async () => {
+            return this.withRetry(async () => {
+                const conn = await this.connect(endpoint);
+                const startTime = Date.now();
+                try {
+                    let response;
+                    if (conn.protocol === 'http2') {
+                        response = await this.sendHTTP2(conn, data);
+                    }
+                    else {
+                        response = await this.sendHTTP1(conn, endpoint, data);
+                    }
+                    this.recordRequest(startTime, true);
+                    this.emit('request:success', { endpoint, latency: Date.now() - startTime });
+                    return response;
+                }
+                catch (error) {
+                    this.recordRequest(startTime, false);
+                    this.emit('request:failure', { endpoint, error });
+                    throw error;
+                }
+                finally {
+                    const pool = this.pools.get(endpoint);
+                    if (pool) {
+                        pool.release(conn);
+                    }
+                }
+            }, this.config.retryAttempts);
+        });
+    }
+    /**
+     * Check connection health
+     */
+    async healthCheck(endpoint) {
+        const pool = this.pools.get(endpoint);
+        if (!pool) {
+            return {
+                latency: Infinity,
+                packetLoss: 1,
+                throughput: 0,
+                activeStreams: 0,
+                lastHealthCheck: new Date(),
+                state: 'unhealthy',
+                protocol: 'http1'
+            };
+        }
+        const stats = pool.getStats();
+        const recentLatencies = this.latencyBuffer.slice(-100);
+        const avgLatency = recentLatencies.length > 0
+            ? recentLatencies.reduce((a, b) => a + b, 0) / recentLatencies.length
+            : 0;
+        const successRate = this.metrics.totalRequests > 0
+            ? this.metrics.successfulRequests / this.metrics.totalRequests
+            : 0;
+        let state = 'healthy';
+        if (successRate < 0.5 || avgLatency > 5000) {
+            state = 'unhealthy';
+        }
+        else if (successRate < 0.9 || avgLatency > 1000) {
+            state = 'degraded';
+        }
+        return {
+            latency: avgLatency,
+            packetLoss: 1 - successRate,
+            throughput: this.calculateThroughput(),
+            activeStreams: stats.size,
+            lastHealthCheck: new Date(),
+            state,
+            protocol: 'http2' // Assume http2 for now
+        };
+    }
+    /**
+     * Get transport metrics
+     */
+    getMetrics() {
+        const cbState = this.circuitBreaker.getState();
+        this.metrics.circuitBreakerState = cbState.state;
+        let totalConnections = 0;
+        let totalUtilization = 0;
+        this.pools.forEach(pool => {
+            const stats = pool.getStats();
+            totalConnections += stats.size;
+            totalUtilization += stats.utilization;
+        });
+        this.metrics.activeConnections = totalConnections;
+        this.metrics.poolUtilization = this.pools.size > 0
+            ? totalUtilization / this.pools.size
+            : 0;
+        // Calculate latency percentiles
+        if (this.latencyBuffer.length > 0) {
+            const sorted = [...this.latencyBuffer].sort((a, b) => a - b);
+            this.metrics.p50Latency = sorted[Math.floor(sorted.length * 0.5)];
+            this.metrics.p95Latency = sorted[Math.floor(sorted.length * 0.95)];
+            this.metrics.p99Latency = sorted[Math.floor(sorted.length * 0.99)];
+        }
+        return { ...this.metrics };
+    }
+    /**
+     * Execute operation with circuit breaker
+     */
+    async withCircuitBreaker(operation) {
+        return this.circuitBreaker.execute(operation);
+    }
+    /**
+     * Execute operation with retry logic
+     */
+    async withRetry(operation, attempts = 3) {
+        let lastError = null;
+        for (let i = 0; i < attempts; i++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                if (i < attempts - 1) {
+                    // Exponential backoff
+                    const delay = this.config.retryDelay * Math.pow(2, i);
+                    await this.sleep(delay);
+                    this.emit('retry', { attempt: i + 1, delay });
+                }
+            }
+        }
+        throw lastError || new Error('Operation failed after retries');
+    }
+    /**
+     * Close all connections and cleanup
+     */
+    async close() {
+        const drainPromises = Array.from(this.pools.values()).map(pool => pool.drain());
+        await Promise.all(drainPromises);
+        this.pools.clear();
+        this.removeAllListeners();
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    /**
+     * Get or create connection pool for endpoint
+     */
+    getOrCreatePool(endpoint) {
+        let pool = this.pools.get(endpoint);
+        if (!pool) {
+            pool = new ConnectionPool({
+                minSize: this.config.poolSize.min,
+                maxSize: this.config.poolSize.max,
+                idleTimeout: this.config.idleTimeout
+            });
+            this.pools.set(endpoint, pool);
+        }
+        return pool;
+    }
+    /**
+     * Detect best protocol for endpoint
+     */
+    async detectBestProtocol(url) {
+        // For now, prefer HTTP/2 if available
+        if (this.config.enableFallback) {
+            try {
+                // Quick ALPN check would go here
+                return 'http2';
+            }
+            catch {
+                return 'http1';
+            }
+        }
+        return 'http2';
+    }
+    /**
+     * Create HTTP/2 connection
+     */
+    async createHTTP2Connection(url) {
+        return new Promise((resolve, reject) => {
+            const session = http2.connect(url.origin, {
+                maxOutstandingPings: 10,
+                maxSessionMemory: 10,
+                ...this.config.tls
+            });
+            session.on('connect', () => resolve(session));
+            session.on('error', reject);
+            setTimeout(() => reject(new Error('Connection timeout')), 5000);
+        });
+    }
+    /**
+     * Create HTTP/1.1 connection
+     */
+    createHTTP1Connection(url) {
+        const options = {
+            keepAlive: true,
+            maxSockets: this.config.maxStreams,
+            ...this.config.tls
+        };
+        return url.protocol === 'https:'
+            ? new https.Agent(options)
+            : new http.Agent(options);
+    }
+    /**
+     * Send data via HTTP/2
+     */
+    async sendHTTP2(conn, data) {
+        return new Promise((resolve, reject) => {
+            const session = conn.session;
+            const req = session.request({
+                ':method': 'POST',
+                ':path': '/',
+                'content-type': 'application/octet-stream',
+                'content-length': data.length
+            });
+            const chunks = [];
+            req.on('response', (headers) => {
+                const status = headers[':status'];
+                if (status && status >= 400) {
+                    reject(new Error(`HTTP ${status}`));
+                }
+            });
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks)));
+            req.on('error', reject);
+            req.write(data);
+            req.end();
+            // Track stream ID if available
+            const streamId = req.stream?.id;
+            if (streamId !== undefined) {
+                conn.streams.add(streamId);
+                req.on('close', () => conn.streams.delete(streamId));
+            }
+        });
+    }
+    /**
+     * Send data via HTTP/1.1
+     */
+    async sendHTTP1(conn, endpoint, data) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(endpoint);
+            const options = {
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    'Content-Length': data.length
+                },
+                agent: conn.session
+            };
+            const reqFn = url.protocol === 'https:' ? https.request : http.request;
+            const req = reqFn(options, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode >= 400) {
+                        reject(new Error(`HTTP ${res.statusCode}`));
+                    }
+                    else {
+                        resolve(Buffer.concat(chunks));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(data);
+            req.end();
+        });
+    }
+    /**
+     * Record request timing
+     */
+    recordRequest(startTime, success) {
+        const latency = Date.now() - startTime;
+        this.metrics.totalRequests++;
+        if (success) {
+            this.metrics.successfulRequests++;
+        }
+        else {
+            this.metrics.failedRequests++;
+        }
+        this.latencyBuffer.push(latency);
+        if (this.latencyBuffer.length > 1000) {
+            this.latencyBuffer.shift();
+        }
+        // Update average latency
+        this.metrics.avgLatency = this.latencyBuffer.reduce((a, b) => a + b, 0) / this.latencyBuffer.length;
+    }
+    /**
+     * Calculate throughput
+     */
+    calculateThroughput() {
+        const windowMs = 60000; // 1 minute window
+        const now = Date.now();
+        const recentRequests = this.requests.filter(r => r.endTime && (now - r.endTime) < windowMs);
+        if (recentRequests.length === 0)
+            return 0;
+        const totalBytes = this.metrics.bytesSent + this.metrics.bytesReceived;
+        return totalBytes / (windowMs / 1000); // bytes per second
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Fallback to HTTP/2 (already implemented as primary)
+     */
+    async fallbackToHTTP2(endpoint) {
+        return this.connect(endpoint);
+    }
+    /**
+     * Fallback to HTTP/1.1
+     */
+    async fallbackToHTTP1(endpoint) {
+        const pool = this.getOrCreatePool(endpoint);
+        const conn = await pool.acquire();
+        if (!conn.endpoint) {
+            const url = new URL(endpoint);
+            conn.session = this.createHTTP1Connection(url);
+            conn.protocol = 'http1';
+            conn.endpoint = endpoint;
+        }
+        return conn;
+    }
+}
+exports.QUICTransport = QUICTransport;
+/**
+ * Default QUIC configuration
+ */
+exports.DEFAULT_QUIC_CONFIG = {
+    host: 'localhost',
+    port: 4433,
+    maxStreams: 100,
+    idleTimeout: 30000,
+    enableFallback: true,
+    retryAttempts: 3,
+    retryDelay: 1000,
+    poolSize: {
+        min: 2,
+        max: 10
+    },
+    circuitBreaker: {
+        failureThreshold: 5,
+        successThreshold: 2,
+        timeout: 60000
+    },
+    enableTLS: false
+};
+/**
+ * Create QUIC transport with default configuration
+ */
+function createQUICTransport(config) {
+    return new QUICTransport({
+        ...exports.DEFAULT_QUIC_CONFIG,
+        ...config
+    });
+}
+//# sourceMappingURL=QUICTransport.js.map