agentic-flow 1.9.4 → 1.10.1

package/dist/utils/http2-multiplexing.js

@@ -0,0 +1,319 @@
+/**
+ * HTTP/2 Multiplexing Optimization
+ * Stream prioritization and flow control for concurrent request optimization
+ * Phase 2 Optimization
+ */
+/**
+ * HTTP/2 Multiplexing Manager
+ * Manages stream prioritization and concurrent request handling
+ */
+export class HTTP2MultiplexingManager {
+    config;
+    activeStreams = new Map();
+    priorityQueues = new Map();
+    stats;
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            maxConcurrentStreams: config.maxConcurrentStreams || 100,
+            defaultPriority: config.defaultPriority || 16,
+            enableFlowControl: config.enableFlowControl !== false,
+            initialWindowSize: config.initialWindowSize || 65535
+        };
+        this.stats = {
+            totalStreams: 0,
+            activeStreams: 0,
+            completedStreams: 0,
+            averageDuration: 0,
+            priorityChanges: 0
+        };
+        this.initializePriorityQueues();
+    }
+    /**
+     * Initialize priority queues (1-256)
+     */
+    initializePriorityQueues() {
+        for (let i = 1; i <= 256; i++) {
+            this.priorityQueues.set(i, new Set());
+        }
+    }
+    /**
+     * Register a new stream
+     */
+    registerStream(stream, priority) {
+        if (!this.config.enabled)
+            return;
+        const streamId = stream.id || 0;
+        const streamPriority = priority?.weight || this.config.defaultPriority;
+        const info = {
+            stream,
+            priority: streamPriority,
+            bytesReceived: 0,
+            bytesSent: 0,
+            startTime: Date.now(),
+            state: 'open'
+        };
+        this.activeStreams.set(streamId, info);
+        this.priorityQueues.get(streamPriority)?.add(streamId);
+        this.stats.totalStreams++;
+        this.stats.activeStreams++;
+        // Set stream priority
+        if (priority) {
+            this.setPriority(stream, priority);
+        }
+        // Setup event handlers
+        this.setupStreamHandlers(stream, streamId);
+    }
+    /**
+     * Set stream priority
+     */
+    setPriority(stream, priority) {
+        try {
+            stream.priority(priority);
+            const streamId = stream.id || 0;
+            const info = this.activeStreams.get(streamId);
+            if (info) {
+                // Move to new priority queue
+                const oldPriority = info.priority;
+                const newPriority = priority.weight;
+                this.priorityQueues.get(oldPriority)?.delete(streamId);
+                info.priority = newPriority;
+                this.priorityQueues.get(newPriority)?.add(streamId);
+                this.stats.priorityChanges++;
+            }
+        }
+        catch (error) {
+            // Stream may be closed
+        }
+    }
+    /**
+     * Adjust stream priority based on load
+     */
+    adjustPriority(streamId, adjustment) {
+        const info = this.activeStreams.get(streamId);
+        if (!info)
+            return;
+        const newPriority = Math.max(1, Math.min(256, info.priority + adjustment));
+        this.setPriority(info.stream, {
+            weight: newPriority,
+            exclusive: false
+        });
+    }
+    /**
+     * Get next stream to process based on priority
+     */
+    getNextStream() {
+        // Process highest priority streams first (256 is highest)
+        for (let priority = 256; priority >= 1; priority--) {
+            const queue = this.priorityQueues.get(priority);
+            if (queue && queue.size > 0) {
+                const streamId = queue.values().next().value;
+                if (streamId !== undefined) {
+                    const info = this.activeStreams.get(streamId);
+                    if (info && info.state === 'open') {
+                        return info.stream;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Setup stream event handlers
+     */
+    setupStreamHandlers(stream, streamId) {
+        stream.on('data', (chunk) => {
+            const info = this.activeStreams.get(streamId);
+            if (info) {
+                info.bytesReceived += chunk.length;
+            }
+        });
+        stream.on('end', () => {
+            this.updateStreamState(streamId, 'half-closed');
+        });
+        stream.on('close', () => {
+            this.handleStreamClose(streamId);
+        });
+        stream.on('error', () => {
+            this.handleStreamClose(streamId);
+        });
+    }
+    /**
+     * Update stream state
+     */
+    updateStreamState(streamId, state) {
+        const info = this.activeStreams.get(streamId);
+        if (info) {
+            info.state = state;
+        }
+    }
+    /**
+     * Handle stream closure
+     */
+    handleStreamClose(streamId) {
+        const info = this.activeStreams.get(streamId);
+        if (!info)
+            return;
+        // Remove from priority queue
+        this.priorityQueues.get(info.priority)?.delete(streamId);
+        // Update statistics
+        const duration = Date.now() - info.startTime;
+        this.updateStats(duration);
+        // Remove from active streams
+        this.activeStreams.delete(streamId);
+        this.stats.activeStreams--;
+        this.stats.completedStreams++;
+    }
+    /**
+     * Update statistics
+     */
+    updateStats(duration) {
+        const currentAvg = this.stats.averageDuration;
+        const total = this.stats.completedStreams;
+        this.stats.averageDuration = (currentAvg * (total - 1) + duration) / total;
+    }
+    /**
+     * Get stream statistics
+     */
+    getStreamStats(streamId) {
+        const info = this.activeStreams.get(streamId);
+        if (!info)
+            return null;
+        return {
+            streamId,
+            priority: info.priority,
+            bytesReceived: info.bytesReceived,
+            bytesSent: info.bytesSent,
+            duration: Date.now() - info.startTime,
+            state: info.state
+        };
+    }
+    /**
+     * Get all statistics
+     */
+    getStats() {
+        const priorityDistribution = new Map();
+        for (const [priority, queue] of this.priorityQueues) {
+            if (queue.size > 0) {
+                priorityDistribution.set(priority, queue.size);
+            }
+        }
+        return {
+            ...this.stats,
+            priorityDistribution
+        };
+    }
+    /**
+     * Check if can accept more streams
+     */
+    canAcceptStream() {
+        return this.stats.activeStreams < this.config.maxConcurrentStreams;
+    }
+    /**
+     * Get load percentage
+     */
+    getLoad() {
+        return (this.stats.activeStreams / this.config.maxConcurrentStreams) * 100;
+    }
+}
+/**
+ * Flow Control Manager
+ * Manages HTTP/2 flow control for optimal throughput
+ */
+export class FlowControlManager {
+    windowSizes = new Map();
+    config;
+    constructor(config) {
+        this.config = {
+            initialWindowSize: config?.initialWindowSize || 65535,
+            maxWindowSize: config?.maxWindowSize || 16777215, // 16MB
+            minWindowSize: config?.minWindowSize || 16384 // 16KB
+        };
+    }
+    /**
+     * Initialize window size for a stream
+     */
+    initializeWindow(streamId) {
+        this.windowSizes.set(streamId, this.config.initialWindowSize);
+    }
+    /**
+     * Update window size
+     */
+    updateWindow(streamId, delta) {
+        const current = this.windowSizes.get(streamId) || this.config.initialWindowSize;
+        const newSize = Math.max(this.config.minWindowSize, Math.min(this.config.maxWindowSize, current + delta));
+        this.windowSizes.set(streamId, newSize);
+        return newSize;
+    }
+    /**
+     * Get current window size
+     */
+    getWindowSize(streamId) {
+        return this.windowSizes.get(streamId) || this.config.initialWindowSize;
+    }
+    /**
+     * Calculate optimal window size based on throughput
+     */
+    calculateOptimalWindow(throughputBps, rttMs) {
+        // Bandwidth-Delay Product
+        const bdp = (throughputBps / 8) * (rttMs / 1000);
+        return Math.max(this.config.minWindowSize, Math.min(this.config.maxWindowSize, Math.ceil(bdp * 2)));
+    }
+    /**
+     * Clean up closed stream
+     */
+    cleanup(streamId) {
+        this.windowSizes.delete(streamId);
+    }
+}
+/**
+ * Priority scheduler for optimal stream processing
+ */
+export class PriorityScheduler {
+    queues = new Map();
+    /**
+     * Add stream to priority queue
+     */
+    enqueue(streamId, priority) {
+        if (!this.queues.has(priority)) {
+            this.queues.set(priority, []);
+        }
+        this.queues.get(priority).push(streamId);
+    }
+    /**
+     * Get next stream to process
+     */
+    dequeue() {
+        // Process highest priority first
+        for (let priority = 256; priority >= 1; priority--) {
+            const queue = this.queues.get(priority);
+            if (queue && queue.length > 0) {
+                return queue.shift();
+            }
+        }
+        return null;
+    }
+    /**
+     * Remove stream from all queues
+     */
+    remove(streamId) {
+        for (const queue of this.queues.values()) {
+            const index = queue.indexOf(streamId);
+            if (index !== -1) {
+                queue.splice(index, 1);
+            }
+        }
+    }
+    /**
+     * Get queue sizes
+     */
+    getStats() {
+        const stats = new Map();
+        for (const [priority, queue] of this.queues) {
+            if (queue.length > 0) {
+                stats.set(priority, queue.length);
+            }
+        }
+        return stats;
+    }
+}

package/dist/utils/lazy-auth.js

@@ -0,0 +1,311 @@
+/**
+ * Lazy Authentication with Session Caching
+ * Reduces auth overhead by 5-10% through session caching and lazy validation
+ * Phase 3 Optimization
+ */
+/**
+ * Lazy Authentication Manager
+ * Caches validated sessions to avoid repeated authentication overhead
+ */
+export class LazyAuthManager {
+    config;
+    sessions = new Map();
+    stats;
+    cleanupTimer;
+    validationQueue = new Set();
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            ttl: config.ttl || 3600000, // 1 hour default
+            maxSessions: config.maxSessions || 1000,
+            checkInterval: config.checkInterval || 60000 // 1 minute
+        };
+        this.stats = {
+            totalValidations: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            sessionsActive: 0,
+            sessionsCleaned: 0,
+            avgValidationTime: 0
+        };
+        if (this.config.enabled) {
+            this.startCleanupTimer();
+        }
+    }
+    /**
+     * Authenticate a token (lazy validation)
+     */
+    async authenticate(token, validateFn) {
+        if (!this.config.enabled) {
+            // No caching, always validate
+            const userId = await validateFn(token);
+            return this.createSession(token, userId, true);
+        }
+        // Check cache first
+        const cached = this.sessions.get(token);
+        if (cached && !this.isExpired(cached)) {
+            this.stats.cacheHits++;
+            cached.lastAccessedAt = Date.now();
+            return cached;
+        }
+        this.stats.cacheMisses++;
+        // Lazy validation: check if already being validated
+        if (this.validationQueue.has(token)) {
+            // Wait for ongoing validation
+            return this.waitForValidation(token);
+        }
+        // Perform validation
+        return this.validateAndCache(token, validateFn);
+    }
+    /**
+     * Validate token and cache the session
+     */
+    async validateAndCache(token, validateFn) {
+        this.validationQueue.add(token);
+        try {
+            const startTime = Date.now();
+            const userId = await validateFn(token);
+            const validationTime = Date.now() - startTime;
+            // Update average validation time
+            this.updateAvgValidationTime(validationTime);
+            this.stats.totalValidations++;
+            // Create and cache session
+            const session = this.createSession(token, userId, true);
+            this.cacheSession(session);
+            return session;
+        }
+        catch (error) {
+            return null;
+        }
+        finally {
+            this.validationQueue.delete(token);
+        }
+    }
+    /**
+     * Wait for ongoing validation
+     */
+    async waitForValidation(token) {
+        // Poll for validation completion (max 5 seconds)
+        const maxAttempts = 50;
+        let attempts = 0;
+        while (this.validationQueue.has(token) && attempts < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            attempts++;
+        }
+        // Check cache after validation
+        const session = this.sessions.get(token);
+        return session && !this.isExpired(session) ? session : null;
+    }
+    /**
+     * Create a session object
+     */
+    createSession(token, userId, validated) {
+        const now = Date.now();
+        return {
+            token,
+            userId,
+            validated,
+            createdAt: now,
+            lastAccessedAt: now,
+            expiresAt: now + this.config.ttl
+        };
+    }
+    /**
+     * Cache a session
+     */
+    cacheSession(session) {
+        // Check max sessions limit
+        if (this.sessions.size >= this.config.maxSessions) {
+            this.evictOldest();
+        }
+        this.sessions.set(session.token, session);
+        this.stats.sessionsActive = this.sessions.size;
+    }
+    /**
+     * Check if session is expired
+     */
+    isExpired(session) {
+        return Date.now() > session.expiresAt;
+    }
+    /**
+     * Evict oldest session (LRU)
+     */
+    evictOldest() {
+        let oldest = null;
+        let oldestToken = null;
+        for (const [token, session] of this.sessions) {
+            if (!oldest || session.lastAccessedAt < oldest.lastAccessedAt) {
+                oldest = session;
+                oldestToken = token;
+            }
+        }
+        if (oldestToken) {
+            this.sessions.delete(oldestToken);
+            this.stats.sessionsCleaned++;
+        }
+    }
+    /**
+     * Update average validation time
+     */
+    updateAvgValidationTime(newTime) {
+        const total = this.stats.totalValidations;
+        const currentAvg = this.stats.avgValidationTime;
+        this.stats.avgValidationTime = (currentAvg * total + newTime) / (total + 1);
+    }
+    /**
+     * Start cleanup timer for expired sessions
+     */
+    startCleanupTimer() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, this.config.checkInterval);
+    }
+    /**
+     * Clean up expired sessions
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [token, session] of this.sessions) {
+            if (now > session.expiresAt) {
+                this.sessions.delete(token);
+                cleaned++;
+            }
+        }
+        this.stats.sessionsCleaned += cleaned;
+        this.stats.sessionsActive = this.sessions.size;
+    }
+    /**
+     * Invalidate a session
+     */
+    invalidate(token) {
+        return this.sessions.delete(token);
+    }
+    /**
+     * Invalidate all sessions for a user
+     */
+    invalidateUser(userId) {
+        let count = 0;
+        for (const [token, session] of this.sessions) {
+            if (session.userId === userId) {
+                this.sessions.delete(token);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Get session if exists and valid
+     */
+    getSession(token) {
+        const session = this.sessions.get(token);
+        if (!session || this.isExpired(session)) {
+            return null;
+        }
+        session.lastAccessedAt = Date.now();
+        return session;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get cache hit rate
+     */
+    getCacheHitRate() {
+        const total = this.stats.cacheHits + this.stats.cacheMisses;
+        return total > 0 ? (this.stats.cacheHits / total) * 100 : 0;
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalValidations: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            sessionsActive: this.sessions.size,
+            sessionsCleaned: 0,
+            avgValidationTime: 0
+        };
+    }
+    /**
+     * Clear all sessions
+     */
+    clear() {
+        this.sessions.clear();
+        this.stats.sessionsActive = 0;
+    }
+    /**
+     * Destroy manager and cleanup
+     */
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        this.clear();
+    }
+}
+/**
+ * Token-based authentication helper
+ */
+export class TokenAuth {
+    authManager;
+    validateFn;
+    constructor(authManager, validateFn) {
+        this.authManager = authManager;
+        this.validateFn = validateFn;
+    }
+    /**
+     * Authenticate a request
+     */
+    async authenticate(authHeader) {
+        // Extract token from header
+        const token = this.extractToken(authHeader);
+        if (!token) {
+            return null;
+        }
+        return this.authManager.authenticate(token, this.validateFn);
+    }
+    /**
+     * Extract token from Authorization header
+     */
+    extractToken(authHeader) {
+        if (!authHeader) {
+            return null;
+        }
+        // Support "Bearer <token>" and raw token
+        if (authHeader.startsWith('Bearer ')) {
+            return authHeader.substring(7);
+        }
+        return authHeader;
+    }
+    /**
+     * Invalidate token
+     */
+    invalidate(token) {
+        return this.authManager.invalidate(token);
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return this.authManager.getStats();
+    }
+}
+/**
+ * Calculate auth overhead reduction
+ */
+export function calculateAuthSavings(stats) {
+    const hitRate = stats.cacheHits / (stats.cacheHits + stats.cacheMisses);
+    const savingsPercentage = hitRate * 100;
+    const avgSavedTime = stats.avgValidationTime * hitRate;
+    const totalSavedTime = stats.avgValidationTime * stats.cacheHits;
+    return {
+        savingsPercentage,
+        avgSavedTime,
+        totalSavedTime
+    };
+}

package/dist/utils/rate-limiter.js

@@ -0,0 +1,48 @@
+/**
+ * Simple in-memory rate limiter for proxy protection
+ */
+export class RateLimiter {
+    config;
+    clients = new Map();
+    cleanupInterval;
+    constructor(config) {
+        this.config = config;
+        // Cleanup expired entries every minute
+        this.cleanupInterval = setInterval(() => {
+            const now = Date.now();
+            for (const [key, record] of this.clients.entries()) {
+                if (record.resetTime < now && (!record.blockedUntil || record.blockedUntil < now)) {
+                    this.clients.delete(key);
+                }
+            }
+        }, 60000);
+    }
+    async consume(key) {
+        const now = Date.now();
+        const record = this.clients.get(key);
+        // Check if client is blocked
+        if (record?.blockedUntil && record.blockedUntil > now) {
+            const remainingMs = record.blockedUntil - now;
+            throw new Error(`Rate limit exceeded. Try again in ${Math.ceil(remainingMs / 1000)} seconds`);
+        }
+        // Initialize or reset record
+        if (!record || record.resetTime < now) {
+            this.clients.set(key, {
+                count: 1,
+                resetTime: now + this.config.duration * 1000
+            });
+            return;
+        }
+        // Increment count
+        record.count++;
+        // Check if limit exceeded
+        if (record.count > this.config.points) {
+            record.blockedUntil = now + this.config.blockDuration * 1000;
+            throw new Error(`Rate limit exceeded (${this.config.points} requests per ${this.config.duration}s)`);
+        }
+    }
+    destroy() {
+        clearInterval(this.cleanupInterval);
+        this.clients.clear();
+    }
+}