agentic-qe 2.7.4 → 2.8.0

package/dist/edge/p2p/protocol/AgentChannel.js

@@ -0,0 +1,914 @@
+"use strict";
+/**
+ * Agent Channel for High-Level Agent-to-Agent Communication
+ *
+ * Provides a high-level API for agent-to-agent communication including
+ * request/response patterns with correlation IDs, event subscription/publication,
+ * typed message handlers, channel lifecycle management, and metrics collection.
+ *
+ * @module edge/p2p/protocol/AgentChannel
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentChannel = exports.ChannelEventType = void 0;
+exports.createAgentChannel = createAgentChannel;
+exports.createAgentChannels = createAgentChannels;
+const types_1 = require("./types");
+const MessageEncoder_1 = require("./MessageEncoder");
+const MessageRouter_1 = require("./MessageRouter");
+const ProtocolHandler_1 = require("./ProtocolHandler");
+/**
+ * Channel event types
+ */
+var ChannelEventType;
+(function (ChannelEventType) {
+    ChannelEventType["OPENED"] = "opened";
+    ChannelEventType["CLOSED"] = "closed";
+    ChannelEventType["ERROR"] = "error";
+    ChannelEventType["RECONNECTING"] = "reconnecting";
+    ChannelEventType["RECONNECTED"] = "reconnected";
+    ChannelEventType["MESSAGE_RECEIVED"] = "message_received";
+    ChannelEventType["MESSAGE_SENT"] = "message_sent";
+    ChannelEventType["STATE_CHANGED"] = "state_changed";
+})(ChannelEventType || (exports.ChannelEventType = ChannelEventType = {}));
+// ============================================
+// AgentChannel Class
+// ============================================
+/**
+ * High-level agent-to-agent communication channel
+ *
+ * @example
+ * ```typescript
+ * const channel = new AgentChannel({
+ *   localIdentity: myIdentity,
+ *   localKeyPair: myKeyPair,
+ *   remoteAgentId: 'remote-agent-id',
+ *   connectionManager: peerManager,
+ * });
+ *
+ * // Open channel
+ * await channel.open();
+ *
+ * // Register request handler
+ * channel.onRequest('get-data', async (params) => {
+ *   return { data: 'response' };
+ * });
+ *
+ * // Send request
+ * const result = await channel.request('process-task', { taskId: '123' });
+ *
+ * // Subscribe to events
+ * channel.subscribe('task-completed', (data) => {
+ *   console.log('Task completed:', data);
+ * });
+ *
+ * // Publish event
+ * await channel.publish('status-update', { status: 'active' });
+ *
+ * // Close channel
+ * await channel.close();
+ * ```
+ */
+class AgentChannel {
+    constructor(options) {
+        // State
+        this.isOpen = false;
+        this.isClosing = false;
+        this.reconnectAttempts = 0;
+        this.openedAt = null;
+        // Request/Response tracking
+        this.pendingRequests = new Map();
+        this.requestHandlers = new Map();
+        // Event subscriptions
+        this.eventSubscriptions = [];
+        // Event handlers
+        this.channelEventHandlers = [];
+        this.errorHandlers = [];
+        this.stateChangeHandlers = [];
+        // Reconnection
+        this.reconnectTimer = null;
+        this.localIdentity = options.localIdentity;
+        this.localKeyPair = options.localKeyPair;
+        this.remoteAgentId = options.remoteAgentId;
+        this.connectionManager = options.connectionManager;
+        this.config = {
+            localAgentId: options.localIdentity.agentId,
+            remoteAgentId: options.remoteAgentId,
+            protocolVersion: options.config?.protocolVersion,
+            features: options.config?.features ?? [
+                types_1.ProtocolFeature.COMPRESSION,
+                types_1.ProtocolFeature.REQUEST_RESPONSE,
+                types_1.ProtocolFeature.PUB_SUB,
+                types_1.ProtocolFeature.RELIABLE_DELIVERY,
+            ],
+            rateLimit: options.config?.rateLimit,
+            queue: options.config?.queue,
+            requestTimeout: options.config?.requestTimeout ?? types_1.DEFAULT_REQUEST_TIMEOUT,
+            heartbeatInterval: options.config?.heartbeatInterval,
+            autoReconnect: options.config?.autoReconnect ?? true,
+            maxReconnectAttempts: options.config?.maxReconnectAttempts ?? 5,
+        };
+        // Initialize protocol handler
+        this.protocolHandler = new ProtocolHandler_1.ProtocolHandler({
+            identity: this.localIdentity,
+            keyPair: this.localKeyPair,
+            features: this.config.features,
+            heartbeatInterval: this.config.heartbeatInterval,
+            rateLimit: this.config.rateLimit,
+        });
+        // Initialize encoder
+        this.encoder = new MessageEncoder_1.MessageEncoder();
+        // Initialize router
+        this.router = new MessageRouter_1.MessageRouter({
+            queue: this.config.queue,
+            enableRetry: true,
+            enableDeadLetter: true,
+        });
+        // Initialize stats
+        this.stats = this.createInitialStats();
+        // Setup event forwarding
+        this.setupEventForwarding();
+    }
+    // ============================================
+    // Lifecycle
+    // ============================================
+    /**
+     * Open the channel and establish connection
+     */
+    async open() {
+        if (this.isOpen) {
+            throw new types_1.ProtocolError('Channel already open', types_1.ProtocolErrorCode.INVALID_STATE);
+        }
+        if (this.isClosing) {
+            throw new types_1.ProtocolError('Channel is closing', types_1.ProtocolErrorCode.INVALID_STATE);
+        }
+        try {
+            // Register with router
+            this.registerWithRouter();
+            // Create handshake
+            const handshakeEnvelope = await this.protocolHandler.createHandshake();
+            // Encode and send handshake
+            await this.sendEnvelope(handshakeEnvelope);
+            // Wait for handshake acknowledgment (handled in message processing)
+            // For now, mark as open after handshake is sent
+            // In production, this should wait for HANDSHAKE_ACK
+            this.isOpen = true;
+            this.openedAt = Date.now();
+            this.stats.openedAt = this.openedAt;
+            this.emitChannelEvent({
+                type: ChannelEventType.OPENED,
+                timestamp: Date.now(),
+                details: { remoteAgentId: this.remoteAgentId },
+            });
+        }
+        catch (error) {
+            this.handleError(error instanceof types_1.ProtocolError
+                ? error
+                : new types_1.ProtocolError(error instanceof Error ? error.message : 'Failed to open channel', types_1.ProtocolErrorCode.PROTOCOL_ERROR));
+            throw error;
+        }
+    }
+    /**
+     * Close the channel gracefully
+     */
+    async close(reason = 'Channel closed') {
+        if (!this.isOpen || this.isClosing)
+            return;
+        this.isClosing = true;
+        try {
+            // Create and send close message
+            const closeEnvelope = await this.protocolHandler.createClose(types_1.CloseCode.NORMAL, reason, false);
+            await this.sendEnvelope(closeEnvelope);
+        }
+        catch {
+            // Ignore send errors during close
+        }
+        this.cleanup();
+        this.isOpen = false;
+        this.isClosing = false;
+        this.emitChannelEvent({
+            type: ChannelEventType.CLOSED,
+            timestamp: Date.now(),
+            details: { reason },
+        });
+    }
+    /**
+     * Check if channel is open
+     */
+    isChannelOpen() {
+        return this.isOpen && !this.isClosing;
+    }
+    /**
+     * Get channel state
+     */
+    getState() {
+        return this.protocolHandler.getState();
+    }
+    // ============================================
+    // Request/Response Pattern
+    // ============================================
+    /**
+     * Send a request and wait for response
+     *
+     * @param method - Method name to call
+     * @param params - Request parameters
+     * @param timeout - Optional timeout override
+     * @returns Promise resolving to response data
+     */
+    async request(method, params, timeout) {
+        if (!this.isChannelOpen()) {
+            throw new types_1.ProtocolError('Channel not open', types_1.ProtocolErrorCode.INVALID_STATE);
+        }
+        const correlationId = (0, types_1.generateMessageId)();
+        const requestTimeout = timeout ?? this.config.requestTimeout ?? types_1.DEFAULT_REQUEST_TIMEOUT;
+        return new Promise((resolve, reject) => {
+            // Create timeout
+            const timer = setTimeout(() => {
+                const pending = this.pendingRequests.get(correlationId);
+                if (pending) {
+                    this.pendingRequests.delete(correlationId);
+                    reject(new types_1.ProtocolError(`Request timed out: ${method}`, types_1.ProtocolErrorCode.TIMEOUT));
+                }
+            }, requestTimeout);
+            // Track pending request
+            const pending = {
+                correlationId,
+                method,
+                sentAt: Date.now(),
+                timeout: requestTimeout,
+                resolve: resolve,
+                reject,
+                timer,
+            };
+            this.pendingRequests.set(correlationId, pending);
+            // Send request
+            this.sendRequest(method, params, correlationId).catch((error) => {
+                this.pendingRequests.delete(correlationId);
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Register a request handler
+     */
+    onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+    }
+    /**
+     * Remove a request handler
+     */
+    offRequest(method) {
+        this.requestHandlers.delete(method);
+    }
+    /**
+     * Send a request (internal)
+     */
+    async sendRequest(method, params, correlationId) {
+        const envelope = await this.protocolHandler.createRequest(method, params, this.remoteAgentId, this.config.requestTimeout);
+        // Override correlation ID
+        envelope.header.correlationId = correlationId;
+        await this.sendEnvelope(envelope);
+        this.stats.requestsSent++;
+    }
+    /**
+     * Handle incoming request
+     */
+    async handleRequest(envelope) {
+        const { method, params } = envelope.payload;
+        const correlationId = envelope.header.messageId;
+        const handler = this.requestHandlers.get(method);
+        if (!handler) {
+            // Send error response
+            const errorEnvelope = await this.protocolHandler.createErrorResponse(correlationId, new types_1.ProtocolError(`Unknown method: ${method}`, types_1.ProtocolErrorCode.INVALID_MESSAGE), envelope.header.senderId);
+            await this.sendEnvelope(errorEnvelope);
+            return;
+        }
+        try {
+            const result = await handler(params, envelope);
+            const responseEnvelope = await this.protocolHandler.createResponse(correlationId, result, envelope.header.senderId);
+            await this.sendEnvelope(responseEnvelope);
+        }
+        catch (error) {
+            const protocolError = error instanceof types_1.ProtocolError
+                ? error
+                : new types_1.ProtocolError(error instanceof Error ? error.message : 'Request handler failed', types_1.ProtocolErrorCode.PROTOCOL_ERROR);
+            const errorEnvelope = await this.protocolHandler.createErrorResponse(correlationId, protocolError, envelope.header.senderId);
+            await this.sendEnvelope(errorEnvelope);
+        }
+    }
+    /**
+     * Handle incoming response
+     */
+    handleResponse(envelope) {
+        const correlationId = envelope.header.correlationId;
+        if (!correlationId)
+            return;
+        const pending = this.pendingRequests.get(correlationId);
+        if (!pending)
+            return;
+        this.pendingRequests.delete(correlationId);
+        clearTimeout(pending.timer);
+        // Update latency stats
+        const latency = Date.now() - pending.sentAt;
+        this.updateLatencyStats(latency);
+        const { success, result, error } = envelope.payload;
+        if (success) {
+            this.stats.responsesReceived++;
+            pending.resolve(result);
+        }
+        else {
+            pending.reject(error
+                ? types_1.ProtocolError.fromInfo(error)
+                : new types_1.ProtocolError('Request failed', types_1.ProtocolErrorCode.PROTOCOL_ERROR));
+        }
+    }
+    // ============================================
+    // Event Pub/Sub Pattern
+    // ============================================
+    /**
+     * Subscribe to an event
+     *
+     * @param event - Event name to subscribe to
+     * @param handler - Event handler function
+     */
+    subscribe(event, handler) {
+        this.eventSubscriptions.push({
+            event,
+            handler: handler,
+            once: false,
+        });
+    }
+    /**
+     * Subscribe to an event (one time)
+     */
+    subscribeOnce(event, handler) {
+        this.eventSubscriptions.push({
+            event,
+            handler: handler,
+            once: true,
+        });
+    }
+    /**
+     * Unsubscribe from an event
+     */
+    unsubscribe(event, handler) {
+        if (handler) {
+            this.eventSubscriptions = this.eventSubscriptions.filter((sub) => !(sub.event === event && sub.handler === handler));
+        }
+        else {
+            this.eventSubscriptions = this.eventSubscriptions.filter((sub) => sub.event !== event);
+        }
+    }
+    /**
+     * Publish an event
+     */
+    async publish(event, data, requiresAck = false) {
+        if (!this.isChannelOpen()) {
+            throw new types_1.ProtocolError('Channel not open', types_1.ProtocolErrorCode.INVALID_STATE);
+        }
+        const envelope = await this.protocolHandler.createEvent(event, data, this.remoteAgentId, requiresAck);
+        await this.sendEnvelope(envelope);
+        this.stats.eventsPublished++;
+    }
+    /**
+     * Broadcast an event to all connected peers
+     */
+    async broadcast(event, data) {
+        if (!this.isChannelOpen()) {
+            throw new types_1.ProtocolError('Channel not open', types_1.ProtocolErrorCode.INVALID_STATE);
+        }
+        const envelope = await this.protocolHandler.createEvent(event, data, '*', false);
+        const encodedData = await this.encoder.encode(envelope);
+        await this.router.broadcast(envelope, encodedData);
+        this.stats.eventsPublished++;
+    }
+    /**
+     * Handle incoming event
+     */
+    handleEvent(envelope) {
+        const { event, data, requiresAck } = envelope.payload;
+        // Find matching subscriptions
+        const matchingSubscriptions = this.eventSubscriptions.filter((sub) => sub.event === event);
+        // Remove one-time subscriptions
+        this.eventSubscriptions = this.eventSubscriptions.filter((sub) => !(sub.event === event && sub.once));
+        // Invoke handlers
+        for (const subscription of matchingSubscriptions) {
+            try {
+                subscription.handler(data, envelope);
+            }
+            catch (error) {
+                // Emit error but don't stop other handlers
+                this.handleError(new types_1.ProtocolError(`Event handler error: ${error instanceof Error ? error.message : 'Unknown'}`, types_1.ProtocolErrorCode.PROTOCOL_ERROR));
+            }
+        }
+        this.stats.eventsReceived++;
+        // Send acknowledgment if required
+        if (requiresAck) {
+            this.sendAck(envelope.header.messageId, envelope.header.senderId).catch(() => {
+                // Ignore ack send errors
+            });
+        }
+    }
+    // ============================================
+    // Message Handling
+    // ============================================
+    /**
+     * Process incoming message data
+     */
+    async processIncomingData(data) {
+        try {
+            // Decode message
+            const dataBuffer = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+            const envelope = await this.encoder.decode(dataBuffer);
+            // Verify message
+            const verified = await this.protocolHandler.verifyMessage(envelope);
+            if (!verified) {
+                throw new types_1.ProtocolError('Message verification failed', types_1.ProtocolErrorCode.INVALID_SIGNATURE);
+            }
+            // Update stats
+            this.stats.messagesReceived++;
+            this.stats.bytesReceived += dataBuffer.length;
+            this.stats.lastActivityAt = Date.now();
+            // Route to appropriate handler
+            await this.routeIncomingMessage(envelope);
+            this.emitChannelEvent({
+                type: ChannelEventType.MESSAGE_RECEIVED,
+                timestamp: Date.now(),
+                details: {
+                    type: envelope.header.type,
+                    messageId: envelope.header.messageId,
+                },
+            });
+        }
+        catch (error) {
+            this.handleError(error instanceof types_1.ProtocolError
+                ? error
+                : new types_1.ProtocolError(`Failed to process message: ${error instanceof Error ? error.message : 'Unknown'}`, types_1.ProtocolErrorCode.DESERIALIZATION_ERROR));
+        }
+    }
+    /**
+     * Route incoming message to handler
+     */
+    async routeIncomingMessage(envelope) {
+        switch (envelope.header.type) {
+            case types_1.MessageType.REQUEST:
+                await this.handleRequest(envelope);
+                break;
+            case types_1.MessageType.RESPONSE:
+                this.handleResponse(envelope);
+                break;
+            case types_1.MessageType.EVENT:
+                this.handleEvent(envelope);
+                break;
+            case types_1.MessageType.HEARTBEAT:
+                await this.handleHeartbeat(envelope);
+                break;
+            case types_1.MessageType.HANDSHAKE:
+                await this.handleIncomingHandshake(envelope);
+                break;
+            case types_1.MessageType.HANDSHAKE_ACK:
+                await this.handleHandshakeAck(envelope);
+                break;
+            case types_1.MessageType.ACK:
+                this.handleAck(envelope);
+                break;
+            case types_1.MessageType.NACK:
+                this.handleNack(envelope);
+                break;
+            case types_1.MessageType.CLOSE:
+                this.handleClose(envelope);
+                break;
+            case types_1.MessageType.ERROR:
+                this.handleErrorMessage(envelope);
+                break;
+            default:
+                // Unknown message type
+                break;
+        }
+    }
+    /**
+     * Handle incoming handshake
+     */
+    async handleIncomingHandshake(envelope) {
+        const result = await this.protocolHandler.processHandshake(envelope);
+        if (result.success) {
+            const ackEnvelope = await this.protocolHandler.createHandshakeAck(result);
+            await this.sendEnvelope(ackEnvelope);
+            this.isOpen = true;
+            this.openedAt = Date.now();
+            this.stats.openedAt = this.openedAt;
+        }
+    }
+    /**
+     * Handle handshake acknowledgment
+     */
+    async handleHandshakeAck(envelope) {
+        await this.protocolHandler.processHandshakeAck(envelope);
+    }
+    /**
+     * Handle heartbeat
+     */
+    async handleHeartbeat(envelope) {
+        const response = await this.protocolHandler.processHeartbeat(envelope);
+        if (response) {
+            await this.sendEnvelope(response);
+        }
+    }
+    /**
+     * Handle acknowledgment
+     */
+    handleAck(envelope) {
+        const payload = envelope.payload;
+        this.router.processAck(payload.messageId);
+    }
+    /**
+     * Handle negative acknowledgment
+     */
+    handleNack(envelope) {
+        const payload = envelope.payload;
+        this.router.processNack(payload.messageId, payload.reason, payload.retryable);
+    }
+    /**
+     * Handle close message
+     */
+    handleClose(envelope) {
+        const payload = this.protocolHandler.processClose(envelope);
+        this.cleanup();
+        this.isOpen = false;
+        if (payload.reconnect && this.config.autoReconnect) {
+            this.scheduleReconnect();
+        }
+    }
+    /**
+     * Handle error message
+     */
+    handleErrorMessage(envelope) {
+        const payload = envelope.payload;
+        this.handleError(types_1.ProtocolError.fromInfo(payload));
+    }
+    // ============================================
+    // Sending
+    // ============================================
+    /**
+     * Send an envelope over the channel
+     */
+    async sendEnvelope(envelope) {
+        const encodedData = await this.encoder.encode(envelope);
+        // Update stats
+        this.stats.messagesSent++;
+        this.stats.bytesSent += encodedData.length;
+        this.stats.lastActivityAt = Date.now();
+        // Route through router for delivery tracking
+        await this.router.route(envelope, encodedData);
+        this.emitChannelEvent({
+            type: ChannelEventType.MESSAGE_SENT,
+            timestamp: Date.now(),
+            details: {
+                type: envelope.header.type,
+                messageId: envelope.header.messageId,
+            },
+        });
+    }
+    /**
+     * Send acknowledgment
+     */
+    async sendAck(messageId, recipientId) {
+        const ackEnvelope = await this.protocolHandler.createAck(messageId, recipientId);
+        await this.sendEnvelope(ackEnvelope);
+    }
+    // ============================================
+    // Router Integration
+    // ============================================
+    /**
+     * Register this channel with the router
+     */
+    registerWithRouter() {
+        const peer = {
+            peerId: this.remoteAgentId,
+            isConnected: true,
+            send: async (data) => {
+                // Send through WebRTC connection manager if available
+                if (this.connectionManager) {
+                    const dataToSend = typeof data === 'string' ? data : data;
+                    this.connectionManager.send(this.remoteAgentId, 'reliable', {
+                        type: 'protocol-message',
+                        data: typeof dataToSend === 'string' ? dataToSend : Array.from(dataToSend),
+                        timestamp: Date.now(),
+                    });
+                }
+            },
+        };
+        this.router.registerPeer(peer);
+    }
+    // ============================================
+    // Error Handling
+    // ============================================
+    /**
+     * Register error handler
+     */
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    /**
+     * Remove error handler
+     */
+    offError(handler) {
+        const index = this.errorHandlers.indexOf(handler);
+        if (index !== -1) {
+            this.errorHandlers.splice(index, 1);
+        }
+    }
+    /**
+     * Handle error
+     */
+    handleError(error, envelope) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error, envelope);
+            }
+            catch {
+                // Ignore handler errors
+            }
+        }
+        this.emitChannelEvent({
+            type: ChannelEventType.ERROR,
+            timestamp: Date.now(),
+            details: { error: error.message, code: error.code },
+        });
+    }
+    // ============================================
+    // State Change Handling
+    // ============================================
+    /**
+     * Register state change handler
+     */
+    onStateChange(handler) {
+        this.stateChangeHandlers.push(handler);
+    }
+    /**
+     * Remove state change handler
+     */
+    offStateChange(handler) {
+        const index = this.stateChangeHandlers.indexOf(handler);
+        if (index !== -1) {
+            this.stateChangeHandlers.splice(index, 1);
+        }
+    }
+    // ============================================
+    // Reconnection
+    // ============================================
+    /**
+     * Schedule reconnection attempt
+     */
+    scheduleReconnect() {
+        if (!this.config.autoReconnect)
+            return;
+        if (this.reconnectAttempts >= (this.config.maxReconnectAttempts ?? 5))
+            return;
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+        this.reconnectTimer = setTimeout(() => {
+            this.attemptReconnect();
+        }, delay);
+        this.emitChannelEvent({
+            type: ChannelEventType.RECONNECTING,
+            timestamp: Date.now(),
+            details: { attempt: this.reconnectAttempts + 1, delay },
+        });
+    }
+    /**
+     * Attempt to reconnect
+     */
+    async attemptReconnect() {
+        this.reconnectAttempts++;
+        this.stats.reconnectionCount++;
+        try {
+            this.protocolHandler.reset();
+            await this.open();
+            this.reconnectAttempts = 0;
+            this.emitChannelEvent({
+                type: ChannelEventType.RECONNECTED,
+                timestamp: Date.now(),
+                details: { attempts: this.stats.reconnectionCount },
+            });
+        }
+        catch {
+            if (this.reconnectAttempts < (this.config.maxReconnectAttempts ?? 5)) {
+                this.scheduleReconnect();
+            }
+        }
+    }
+    // ============================================
+    // Statistics
+    // ============================================
+    /**
+     * Get channel statistics
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            state: this.protocolHandler.getState(),
+        };
+    }
+    /**
+     * Create initial stats object
+     */
+    createInitialStats() {
+        return {
+            messagesSent: 0,
+            messagesReceived: 0,
+            bytesSent: 0,
+            bytesReceived: 0,
+            requestsSent: 0,
+            responsesReceived: 0,
+            eventsPublished: 0,
+            eventsReceived: 0,
+            averageLatency: 0,
+            state: types_1.ProtocolState.IDLE,
+            lastActivityAt: 0,
+            openedAt: 0,
+            reconnectionCount: 0,
+        };
+    }
+    /**
+     * Update latency statistics
+     */
+    updateLatencyStats(latency) {
+        const count = this.stats.responsesReceived;
+        this.stats.averageLatency =
+            this.stats.averageLatency + (latency - this.stats.averageLatency) / count;
+    }
+    // ============================================
+    // Events
+    // ============================================
+    /**
+     * Add channel event handler
+     */
+    on(handler) {
+        this.channelEventHandlers.push(handler);
+    }
+    /**
+     * Remove channel event handler
+     */
+    off(handler) {
+        const index = this.channelEventHandlers.indexOf(handler);
+        if (index !== -1) {
+            this.channelEventHandlers.splice(index, 1);
+        }
+    }
+    /**
+     * Emit channel event
+     */
+    emitChannelEvent(event) {
+        for (const handler of this.channelEventHandlers) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Ignore handler errors
+            }
+        }
+    }
+    /**
+     * Setup event forwarding from protocol handler and router
+     */
+    setupEventForwarding() {
+        // Forward protocol handler events
+        this.protocolHandler.on((event) => {
+            if (event.type === ProtocolHandler_1.ProtocolEventType.STATE_CHANGED) {
+                const transition = event.details;
+                for (const handler of this.stateChangeHandlers) {
+                    try {
+                        handler(transition);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+                this.emitChannelEvent({
+                    type: ChannelEventType.STATE_CHANGED,
+                    timestamp: event.timestamp,
+                    details: transition,
+                });
+            }
+        });
+        // Forward router events
+        this.router.on((event) => {
+            if (event.type === MessageRouter_1.RouterEventType.MESSAGE_FAILED) {
+                this.emitChannelEvent({
+                    type: ChannelEventType.ERROR,
+                    timestamp: event.timestamp,
+                    details: { messageId: event.messageId, ...(event.details || {}) },
+                });
+            }
+        });
+    }
+    // ============================================
+    // Cleanup
+    // ============================================
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        // Cancel reconnect timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Reject pending requests
+        for (const [, pending] of Array.from(this.pendingRequests.entries())) {
+            clearTimeout(pending.timer);
+            pending.reject(new types_1.ProtocolError('Channel closed', types_1.ProtocolErrorCode.CONNECTION_CLOSED));
+        }
+        this.pendingRequests.clear();
+        // Clear subscriptions
+        this.eventSubscriptions = [];
+        // Stop protocol handler
+        this.protocolHandler.close();
+        // Clear router
+        this.router.destroy();
+    }
+    /**
+     * Destroy the channel and release all resources
+     */
+    destroy() {
+        this.cleanup();
+        this.channelEventHandlers = [];
+        this.errorHandlers = [];
+        this.stateChangeHandlers = [];
+        this.requestHandlers.clear();
+    }
+    // ============================================
+    // Getters
+    // ============================================
+    /**
+     * Get local agent ID
+     */
+    getLocalAgentId() {
+        return this.localIdentity.agentId;
+    }
+    /**
+     * Get remote agent ID
+     */
+    getRemoteAgentId() {
+        return this.remoteAgentId;
+    }
+    /**
+     * Get session ID
+     */
+    getSessionId() {
+        return this.protocolHandler.getSessionId();
+    }
+    /**
+     * Get agreed features
+     */
+    getAgreedFeatures() {
+        return this.protocolHandler.getAgreedFeatures();
+    }
+    /**
+     * Check if a feature is enabled
+     */
+    hasFeature(feature) {
+        return this.protocolHandler.hasFeature(feature);
+    }
+    /**
+     * Get heartbeat latency
+     */
+    getHeartbeatLatency() {
+        return this.protocolHandler.getHeartbeatLatency();
+    }
+    /**
+     * Get rate limit status
+     */
+    getRateLimitStatus() {
+        return this.protocolHandler.getRateLimitStatus();
+    }
+}
+exports.AgentChannel = AgentChannel;
+// ============================================
+// Factory Functions
+// ============================================
+/**
+ * Create a new agent channel
+ */
+function createAgentChannel(options) {
+    return new AgentChannel(options);
+}
+/**
+ * Create multiple channels for an agent
+ */
+function createAgentChannels(localIdentity, localKeyPair, remoteAgentIds, connectionManager, config) {
+    const channels = new Map();
+    for (const remoteAgentId of remoteAgentIds) {
+        const channel = new AgentChannel({
+            localIdentity,
+            localKeyPair,
+            remoteAgentId,
+            connectionManager,
+            config,
+        });
+        channels.set(remoteAgentId, channel);
+    }
+    return channels;
+}
+//# sourceMappingURL=AgentChannel.js.map