agentic-qe 3.3.4 → 3.4.0

package/v3/dist/mcp/transport/sse/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/mcp/transport/sse/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,+EAA+E;AAC/E,8CAA8C;AAC9C,+EAA+E;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,mBAAmB;IACnB,WAAW,EAAE,aAAa;IAC1B,YAAY,EAAE,cAAc;IAC5B,SAAS,EAAE,WAAW;IACtB,YAAY,EAAE,cAAc;IAC5B,aAAa,EAAE,eAAe;IAE9B,sBAAsB;IACtB,kBAAkB,EAAE,oBAAoB;IACxC,oBAAoB,EAAE,sBAAsB;IAC5C,gBAAgB,EAAE,kBAAkB;IAEpC,mBAAmB;IACnB,eAAe,EAAE,iBAAiB;IAClC,cAAc,EAAE,gBAAgB;IAChC,aAAa,EAAE,eAAe;IAC9B,gBAAgB,EAAE,kBAAkB;IAEpC,eAAe;IACf,cAAc,EAAE,gBAAgB;IAChC,WAAW,EAAE,aAAa;IAC1B,iBAAiB,EAAE,mBAAmB;IACtC,iBAAiB,EAAE,mBAAmB;IACtC,cAAc,EAAE,gBAAgB;IAEhC,iBAAiB;IACjB,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;CACR,CAAC"}

package/v3/dist/mcp/transport/websocket/connection-manager.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Agentic QE v3 - WebSocket Connection Manager
+ * Manages WebSocket connection lifecycle, heartbeat, and state recovery
+ *
+ * @module mcp/transport/websocket/connection-manager
+ */
+import { EventEmitter } from 'events';
+import type { WebSocketConnection, WebSocketConnectionState, WebSocketTransportMetrics, StateRecoveryEntry, EventServerMessage } from './types.js';
+export interface WebSocketConnectionManagerConfig {
+    /**
+     * Heartbeat interval in milliseconds (default: 30000)
+     */
+    heartbeatInterval?: number;
+    /**
+     * Heartbeat timeout in milliseconds (default: 10000)
+     */
+    heartbeatTimeout?: number;
+    /**
+     * Connection timeout in milliseconds (default: 300000 = 5 minutes)
+     */
+    connectionTimeout?: number;
+    /**
+     * Maximum concurrent connections (default: 1000)
+     */
+    maxConnections?: number;
+    /**
+     * State recovery buffer size (default: 1000 events)
+     */
+    recoveryBufferSize?: number;
+    /**
+     * Resume token expiration in milliseconds (default: 300000 = 5 minutes)
+     */
+    resumeTokenExpiration?: number;
+    /**
+     * Enable metrics collection (default: true)
+     */
+    enableMetrics?: boolean;
+}
+export declare class WebSocketConnectionManager extends EventEmitter {
+    private readonly config;
+    private readonly connections;
+    private readonly connectionsByThread;
+    private readonly recoveryStore;
+    private readonly closedConnections;
+    private readonly heartbeatTimers;
+    private readonly heartbeatTimeoutTimers;
+    private readonly timeoutTimers;
+    private cleanupTimer;
+    private disposed;
+    constructor(config?: WebSocketConnectionManagerConfig);
+    /**
+     * Create a new WebSocket connection
+     */
+    createConnection(threadId: string, runId?: string): WebSocketConnection;
+    /**
+     * Get connection by ID
+     */
+    getConnection(id: string): WebSocketConnection | undefined;
+    /**
+     * Get connection by thread ID (returns most recent)
+     */
+    getConnectionByThreadId(threadId: string): WebSocketConnection | undefined;
+    /**
+     * Get all active connections
+     */
+    getActiveConnections(): WebSocketConnection[];
+    /**
+     * Update connection state
+     */
+    updateState(id: string, state: WebSocketConnectionState): void;
+    /**
+     * Close connection
+     */
+    closeConnection(id: string, reason?: string): void;
+    /**
+     * Close all connections for a thread
+     */
+    closeThreadConnections(threadId: string, reason?: string): void;
+    /**
+     * Record message sent
+     */
+    recordMessageSent(id: string, bytes: number): void;
+    /**
+     * Record message received
+     */
+    recordMessageReceived(id: string, bytes: number): void;
+    /**
+     * Record event sent
+     */
+    recordEventSent(id: string): number;
+    /**
+     * Record heartbeat
+     */
+    recordHeartbeat(id: string): void;
+    /**
+     * Record error
+     */
+    recordError(id: string): void;
+    /**
+     * Record latency sample
+     */
+    recordLatency(id: string, latencyMs: number): void;
+    /**
+     * Store event for recovery
+     */
+    storeEventForRecovery(connectionId: string, event: EventServerMessage): void;
+    /**
+     * Update state snapshot for recovery
+     */
+    updateRecoveryState(connectionId: string, state: Record<string, unknown>): void;
+    /**
+     * Recover state from resume token
+     */
+    recoverState(resumeToken: string, lastEventId?: string): StateRecoveryEntry | null;
+    /**
+     * Validate resume token
+     */
+    validateResumeToken(resumeToken: string): boolean;
+    /**
+     * Get transport metrics
+     */
+    getMetrics(): WebSocketTransportMetrics;
+    /**
+     * Dispose of the manager and close all connections
+     */
+    dispose(): void;
+    private addToThreadIndex;
+    private removeFromThreadIndex;
+    private generateResumeToken;
+    private createRecoveryEntry;
+    private saveRecoveryState;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private startHeartbeatTimeout;
+    private clearHeartbeatTimeout;
+    private startTimeout;
+    private stopTimeout;
+    private resetTimeout;
+    private startCleanupTimer;
+    private cleanupExpiredRecoveryEntries;
+}
+export declare function createWebSocketConnectionManager(config?: WebSocketConnectionManagerConfig): WebSocketConnectionManager;
+//# sourceMappingURL=connection-manager.d.ts.map

package/v3/dist/mcp/transport/websocket/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../../../src/mcp/transport/websocket/connection-manager.ts"],"names":[],"mappings":"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"}

package/v3/dist/mcp/transport/websocket/connection-manager.js

@@ -0,0 +1,522 @@
+/**
+ * Agentic QE v3 - WebSocket Connection Manager
+ * Manages WebSocket connection lifecycle, heartbeat, and state recovery
+ *
+ * @module mcp/transport/websocket/connection-manager
+ */
+import { v4 as uuid } from 'uuid';
+import { EventEmitter } from 'events';
+const DEFAULT_CONFIG = {
+    heartbeatInterval: 30000,
+    heartbeatTimeout: 10000,
+    connectionTimeout: 300000,
+    maxConnections: 1000,
+    recoveryBufferSize: 1000,
+    resumeTokenExpiration: 300000,
+    enableMetrics: true,
+};
+// ============================================================================
+// Connection Manager Implementation
+// ============================================================================
+export class WebSocketConnectionManager extends EventEmitter {
+    config;
+    connections = new Map();
+    connectionsByThread = new Map();
+    recoveryStore = new Map();
+    closedConnections = [];
+    heartbeatTimers = new Map();
+    heartbeatTimeoutTimers = new Map();
+    timeoutTimers = new Map();
+    cleanupTimer = null;
+    disposed = false;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.startCleanupTimer();
+    }
+    // ============================================================================
+    // Connection Lifecycle
+    // ============================================================================
+    /**
+     * Create a new WebSocket connection
+     */
+    createConnection(threadId, runId) {
+        if (this.disposed) {
+            throw new Error('ConnectionManager has been disposed');
+        }
+        if (this.connections.size >= this.config.maxConnections) {
+            throw new Error(`Maximum connections (${this.config.maxConnections}) exceeded`);
+        }
+        const id = uuid();
+        const actualRunId = runId || uuid();
+        const now = Date.now();
+        const resumeToken = this.generateResumeToken();
+        const connection = {
+            id,
+            threadId,
+            runId: actualRunId,
+            state: 'connecting',
+            resumeToken,
+            createdAt: now,
+            lastActivity: now,
+            lastPing: now,
+            lastEventId: 0,
+            abortController: new AbortController(),
+            metrics: {
+                messagesSent: 0,
+                messagesReceived: 0,
+                eventsSent: 0,
+                bytesSent: 0,
+                bytesReceived: 0,
+                heartbeats: 0,
+                errors: 0,
+                startTime: now,
+                averageLatencyMs: 0,
+                peakLatencyMs: 0,
+            },
+        };
+        this.connections.set(id, connection);
+        this.addToThreadIndex(threadId, id);
+        this.startTimeout(id);
+        this.emit('connectionCreated', { connectionId: id, threadId, runId: actualRunId });
+        return connection;
+    }
+    /**
+     * Get connection by ID
+     */
+    getConnection(id) {
+        return this.connections.get(id);
+    }
+    /**
+     * Get connection by thread ID (returns most recent)
+     */
+    getConnectionByThreadId(threadId) {
+        const connectionIds = this.connectionsByThread.get(threadId);
+        if (!connectionIds || connectionIds.size === 0) {
+            return undefined;
+        }
+        // Find most recently active connection
+        let mostRecent;
+        for (const id of connectionIds) {
+            const conn = this.connections.get(id);
+            if (conn && (!mostRecent || conn.lastActivity > mostRecent.lastActivity)) {
+                mostRecent = conn;
+            }
+        }
+        return mostRecent;
+    }
+    /**
+     * Get all active connections
+     */
+    getActiveConnections() {
+        return Array.from(this.connections.values()).filter((conn) => conn.state === 'connected' ||
+            conn.state === 'authenticated' ||
+            conn.state === 'streaming');
+    }
+    /**
+     * Update connection state
+     */
+    updateState(id, state) {
+        const connection = this.connections.get(id);
+        if (!connection) {
+            return;
+        }
+        const previousState = connection.state;
+        connection.state = state;
+        connection.lastActivity = Date.now();
+        if (state === 'connected' || state === 'authenticated') {
+            this.startHeartbeat(id);
+        }
+        if (state === 'closed' || state === 'error') {
+            connection.metrics.endTime = Date.now();
+            this.stopHeartbeat(id);
+            this.stopTimeout(id);
+        }
+        this.emit('stateChange', {
+            connectionId: id,
+            previousState,
+            newState: state,
+        });
+    }
+    /**
+     * Close connection
+     */
+    closeConnection(id, reason) {
+        const connection = this.connections.get(id);
+        if (!connection) {
+            return;
+        }
+        // Stop timers
+        this.stopHeartbeat(id);
+        this.stopTimeout(id);
+        // Update state
+        connection.state = 'closing';
+        connection.metrics.endTime = Date.now();
+        // Abort any ongoing operations
+        connection.abortController.abort(reason || 'Connection closed');
+        // Save state for recovery
+        this.saveRecoveryState(connection);
+        // Move to closed connections for metrics
+        connection.state = 'closed';
+        this.closedConnections.push(connection);
+        while (this.closedConnections.length > 1000) {
+            this.closedConnections.shift();
+        }
+        // Remove from indexes
+        this.removeFromThreadIndex(connection.threadId, id);
+        this.connections.delete(id);
+        this.emit('connectionClosed', {
+            connectionId: id,
+            threadId: connection.threadId,
+            reason,
+        });
+    }
+    /**
+     * Close all connections for a thread
+     */
+    closeThreadConnections(threadId, reason) {
+        const connectionIds = this.connectionsByThread.get(threadId);
+        if (!connectionIds) {
+            return;
+        }
+        for (const id of Array.from(connectionIds)) {
+            this.closeConnection(id, reason);
+        }
+    }
+    // ============================================================================
+    // Metrics Recording
+    // ============================================================================
+    /**
+     * Record message sent
+     */
+    recordMessageSent(id, bytes) {
+        const connection = this.connections.get(id);
+        if (connection) {
+            connection.metrics.messagesSent++;
+            connection.metrics.bytesSent += bytes;
+            connection.lastActivity = Date.now();
+            this.resetTimeout(id);
+        }
+    }
+    /**
+     * Record message received
+     */
+    recordMessageReceived(id, bytes) {
+        const connection = this.connections.get(id);
+        if (connection) {
+            connection.metrics.messagesReceived++;
+            connection.metrics.bytesReceived += bytes;
+            connection.lastActivity = Date.now();
+            this.resetTimeout(id);
+        }
+    }
+    /**
+     * Record event sent
+     */
+    recordEventSent(id) {
+        const connection = this.connections.get(id);
+        if (connection) {
+            connection.metrics.eventsSent++;
+            connection.lastEventId++;
+            return connection.lastEventId;
+        }
+        return 0;
+    }
+    /**
+     * Record heartbeat
+     */
+    recordHeartbeat(id) {
+        const connection = this.connections.get(id);
+        if (connection) {
+            connection.metrics.heartbeats++;
+            connection.lastPing = Date.now();
+            this.clearHeartbeatTimeout(id);
+        }
+    }
+    /**
+     * Record error
+     */
+    recordError(id) {
+        const connection = this.connections.get(id);
+        if (connection) {
+            connection.metrics.errors++;
+        }
+    }
+    /**
+     * Record latency sample
+     */
+    recordLatency(id, latencyMs) {
+        const connection = this.connections.get(id);
+        if (connection) {
+            // Update peak
+            if (latencyMs > connection.metrics.peakLatencyMs) {
+                connection.metrics.peakLatencyMs = latencyMs;
+            }
+            // Update rolling average
+            const samples = connection.metrics.heartbeats || 1;
+            connection.metrics.averageLatencyMs =
+                (connection.metrics.averageLatencyMs * (samples - 1) + latencyMs) / samples;
+        }
+    }
+    // ============================================================================
+    // State Recovery
+    // ============================================================================
+    /**
+     * Store event for recovery
+     */
+    storeEventForRecovery(connectionId, event) {
+        const connection = this.connections.get(connectionId);
+        if (!connection) {
+            return;
+        }
+        let entry = this.recoveryStore.get(connection.resumeToken);
+        if (!entry) {
+            entry = this.createRecoveryEntry(connection);
+            this.recoveryStore.set(connection.resumeToken, entry);
+        }
+        entry.events.push(event);
+        // Trim buffer if needed
+        while (entry.events.length > this.config.recoveryBufferSize) {
+            entry.events.shift();
+        }
+    }
+    /**
+     * Update state snapshot for recovery
+     */
+    updateRecoveryState(connectionId, state) {
+        const connection = this.connections.get(connectionId);
+        if (!connection) {
+            return;
+        }
+        const entry = this.recoveryStore.get(connection.resumeToken);
+        if (entry) {
+            entry.state = structuredClone(state);
+        }
+    }
+    /**
+     * Recover state from resume token
+     */
+    recoverState(resumeToken, lastEventId) {
+        const entry = this.recoveryStore.get(resumeToken);
+        if (!entry) {
+            return null;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.recoveryStore.delete(resumeToken);
+            return null;
+        }
+        // Filter events if lastEventId provided
+        if (lastEventId) {
+            const eventIdNum = parseInt(lastEventId, 10);
+            if (!isNaN(eventIdNum)) {
+                entry.events = entry.events.filter((e) => {
+                    const id = parseInt(e.eventId, 10);
+                    return !isNaN(id) && id > eventIdNum;
+                });
+            }
+        }
+        return entry;
+    }
+    /**
+     * Validate resume token
+     */
+    validateResumeToken(resumeToken) {
+        const entry = this.recoveryStore.get(resumeToken);
+        return entry !== null && entry !== undefined && Date.now() <= entry.expiresAt;
+    }
+    // ============================================================================
+    // Transport Metrics
+    // ============================================================================
+    /**
+     * Get transport metrics
+     */
+    getMetrics() {
+        const activeConnectionsList = this.getActiveConnections();
+        const allConnections = [
+            ...Array.from(this.connections.values()),
+            ...this.closedConnections,
+        ];
+        const durations = allConnections
+            .filter((c) => c.metrics.endTime)
+            .map((c) => (c.metrics.endTime ?? 0) - c.metrics.startTime);
+        const averageDuration = durations.length > 0
+            ? durations.reduce((a, b) => a + b, 0) / durations.length
+            : 0;
+        // Calculate upgrade success rate (connections that made it to connected state)
+        const successfulConnections = allConnections.filter((c) => c.state === 'connected' ||
+            c.state === 'authenticated' ||
+            c.state === 'streaming' ||
+            (c.state === 'closed' && c.metrics.messagesSent > 0));
+        const upgradeSuccessRate = allConnections.length > 0
+            ? successfulConnections.length / allConnections.length
+            : 1;
+        return {
+            totalConnections: allConnections.length,
+            activeConnections: activeConnectionsList.length,
+            totalMessagesSent: allConnections.reduce((sum, c) => sum + c.metrics.messagesSent, 0),
+            totalMessagesReceived: allConnections.reduce((sum, c) => sum + c.metrics.messagesReceived, 0),
+            totalBytesSent: allConnections.reduce((sum, c) => sum + c.metrics.bytesSent, 0),
+            totalBytesReceived: allConnections.reduce((sum, c) => sum + c.metrics.bytesReceived, 0),
+            totalErrors: allConnections.reduce((sum, c) => sum + c.metrics.errors, 0),
+            totalReconnections: 0, // TODO: track reconnections
+            averageConnectionDuration: averageDuration,
+            upgradeSuccessRate,
+        };
+    }
+    // ============================================================================
+    // Cleanup
+    // ============================================================================
+    /**
+     * Dispose of the manager and close all connections
+     */
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        // Stop cleanup timer
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        // Close all connections
+        const connectionIds = Array.from(this.connections.keys());
+        for (const id of connectionIds) {
+            this.closeConnection(id, 'Manager disposed');
+        }
+        // Clear all timers
+        for (const timer of this.heartbeatTimers.values()) {
+            clearInterval(timer);
+        }
+        this.heartbeatTimers.clear();
+        for (const timer of this.heartbeatTimeoutTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.heartbeatTimeoutTimers.clear();
+        for (const timer of this.timeoutTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.timeoutTimers.clear();
+        // Clear recovery store
+        this.recoveryStore.clear();
+        this.removeAllListeners();
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    addToThreadIndex(threadId, connectionId) {
+        let connections = this.connectionsByThread.get(threadId);
+        if (!connections) {
+            connections = new Set();
+            this.connectionsByThread.set(threadId, connections);
+        }
+        connections.add(connectionId);
+    }
+    removeFromThreadIndex(threadId, connectionId) {
+        const connections = this.connectionsByThread.get(threadId);
+        if (connections) {
+            connections.delete(connectionId);
+            if (connections.size === 0) {
+                this.connectionsByThread.delete(threadId);
+            }
+        }
+    }
+    generateResumeToken() {
+        return `rt_${uuid()}_${Date.now().toString(36)}`;
+    }
+    createRecoveryEntry(connection) {
+        return {
+            resumeToken: connection.resumeToken,
+            threadId: connection.threadId,
+            runId: connection.runId,
+            state: {},
+            events: [],
+            createdAt: Date.now(),
+            expiresAt: Date.now() + this.config.resumeTokenExpiration,
+        };
+    }
+    saveRecoveryState(connection) {
+        const existingEntry = this.recoveryStore.get(connection.resumeToken);
+        if (existingEntry) {
+            // Update expiration
+            existingEntry.expiresAt = Date.now() + this.config.resumeTokenExpiration;
+        }
+        else {
+            // Create new entry
+            this.recoveryStore.set(connection.resumeToken, this.createRecoveryEntry(connection));
+        }
+    }
+    startHeartbeat(id) {
+        if (this.heartbeatTimers.has(id)) {
+            return;
+        }
+        const timer = setInterval(() => {
+            this.emit('heartbeatRequired', { connectionId: id });
+            this.startHeartbeatTimeout(id);
+        }, this.config.heartbeatInterval);
+        this.heartbeatTimers.set(id, timer);
+    }
+    stopHeartbeat(id) {
+        const timer = this.heartbeatTimers.get(id);
+        if (timer) {
+            clearInterval(timer);
+            this.heartbeatTimers.delete(id);
+        }
+        this.clearHeartbeatTimeout(id);
+    }
+    startHeartbeatTimeout(id) {
+        this.clearHeartbeatTimeout(id);
+        const timer = setTimeout(() => {
+            this.emit('heartbeatTimeout', { connectionId: id });
+            this.closeConnection(id, 'Heartbeat timeout');
+        }, this.config.heartbeatTimeout);
+        this.heartbeatTimeoutTimers.set(id, timer);
+    }
+    clearHeartbeatTimeout(id) {
+        const timer = this.heartbeatTimeoutTimers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            this.heartbeatTimeoutTimers.delete(id);
+        }
+    }
+    startTimeout(id) {
+        const timer = setTimeout(() => {
+            this.emit('connectionTimeout', { connectionId: id });
+            this.closeConnection(id, 'Connection timeout');
+        }, this.config.connectionTimeout);
+        this.timeoutTimers.set(id, timer);
+    }
+    stopTimeout(id) {
+        const timer = this.timeoutTimers.get(id);
+        if (timer) {
+            clearTimeout(timer);
+            this.timeoutTimers.delete(id);
+        }
+    }
+    resetTimeout(id) {
+        this.stopTimeout(id);
+        this.startTimeout(id);
+    }
+    startCleanupTimer() {
+        // Clean up expired recovery entries every minute
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupExpiredRecoveryEntries();
+        }, 60000);
+    }
+    cleanupExpiredRecoveryEntries() {
+        const now = Date.now();
+        for (const [token, entry] of this.recoveryStore.entries()) {
+            if (now > entry.expiresAt) {
+                this.recoveryStore.delete(token);
+            }
+        }
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+export function createWebSocketConnectionManager(config) {
+    return new WebSocketConnectionManager(config);
+}
+//# sourceMappingURL=connection-manager.js.map