agentic-flow 3.0.0-alpha.2 → 3.1.0

package/dist/utils/http2-multiplexing.js

@@ -1,319 +0,0 @@
-/**
- * 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

@@ -1,311 +0,0 @@
-/**
- * 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
-    };
-}