agentic-qe 2.3.1 → 2.3.3

package/dist/core/transport/QUICTransport.js

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