claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

package/src/communication/message-bus.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage, hasAgentId } from '../utils/type-guards.js';
 /**
  * Advanced messaging and communication layer for swarm coordination
  */
@@ -6,12 +5,7 @@ import { getErrorMessage, hasAgentId } from '../utils/type-guards.js';
 import { EventEmitter } from 'node:events';
 import type { ILogger } from '../core/logger.js';
 import type { IEventBus } from '../core/event-bus.js';
-import type { 
-  SwarmEvent, 
-  EventType, 
-  AgentId, 
-  CommunicationStrategy 
-} from '../swarm/types.js';
+import type { SwarmEvent, EventType, AgentId, CommunicationStrategy } from '../swarm/types.js';
 import { generateId } from '../utils/helpers.js';
 
 export interface MessageBusConfig {
@@ -242,11 +236,7 @@ export class MessageBus extends EventEmitter {
   private metrics: MessageBusMetrics;
   private metricsInterval?: NodeJS.Timeout;
 
-  constructor(
-    config: Partial<MessageBusConfig>,
-    logger: ILogger,
-    eventBus: IEventBus
-  ) {
+  constructor(config: Partial<MessageBusConfig>, logger: ILogger, eventBus: IEventBus) {
     super();
     this.logger = logger;
     this.eventBus = eventBus;
@@ -267,7 +257,7 @@ export class MessageBus extends EventEmitter {
       encryptionEnabled: false,
       metricsEnabled: true,
       debugMode: false,
-      ...config
+      ...config,
     };
 
     this.router = new MessageRouter(this.config, this.logger);
@@ -308,7 +298,7 @@ export class MessageBus extends EventEmitter {
     this.logger.info('Initializing message bus', {
       strategy: this.config.strategy,
       persistence: this.config.enablePersistence,
-      reliability: this.config.enableReliability
+      reliability: this.config.enableReliability,
     });
 
     // Initialize components
@@ -362,13 +352,13 @@ export class MessageBus extends EventEmitter {
       correlationId?: string;
       replyTo?: string;
       channel?: string;
-    } = {}
+    } = {},
   ): Promise<string> {
     const messageId = generateId('msg');
     const now = new Date();
-    
+
     const receiversArray = Array.isArray(receivers) ? receivers : [receivers];
-    
+
     const message: Message = {
       id: messageId,
       type,
@@ -384,12 +374,12 @@ export class MessageBus extends EventEmitter {
         size: this.calculateSize(content),
         contentType: this.detectContentType(content),
         encoding: 'utf-8',
-        route: [sender.id]
+        route: [sender.id],
       },
       timestamp: now,
       expiresAt: options.ttl ? new Date(now.getTime() + options.ttl) : undefined,
       priority: options.priority || 'normal',
-      reliability: options.reliability || 'best-effort'
+      reliability: options.reliability || 'best-effort',
     };
 
     // Validate message
@@ -409,8 +399,8 @@ export class MessageBus extends EventEmitter {
       messageId,
       type,
       sender: sender.id,
-      receivers: receiversArray.map(r => r.id),
-      size: message.metadata.size
+      receivers: receiversArray.map((r) => r.id),
+      size: message.metadata.size,
     });
 
     this.emit('message:sent', { message });
@@ -427,18 +417,18 @@ export class MessageBus extends EventEmitter {
       filter?: MessageFilter;
       priority?: MessagePriority;
       ttl?: number;
-    } = {}
+    } = {},
   ): Promise<string> {
-    const channel = options.channel ? 
-      this.channels.get(options.channel) : 
-      this.getDefaultBroadcastChannel();
+    const channel = options.channel
+      ? this.channels.get(options.channel)
+      : this.getDefaultBroadcastChannel();
 
     if (!channel) {
       throw new Error('No broadcast channel available');
     }
 
     // Get all participants as receivers
-    let receivers = channel.participants.filter(p => p.id !== sender.id);
+    let receivers = channel.participants.filter((p) => p.id !== sender.id);
 
     // Apply filter if provided
     if (options.filter) {
@@ -448,7 +438,7 @@ export class MessageBus extends EventEmitter {
     return this.sendMessage(type, content, sender, receivers, {
       priority: options.priority,
       ttl: options.ttl,
-      channel: channel.id
+      channel: channel.id,
     });
   }
 
@@ -459,10 +449,10 @@ export class MessageBus extends EventEmitter {
       filter?: MessageFilter;
       qos?: QualityOfService;
       ackRequired?: boolean;
-    } = {}
+    } = {},
   ): Promise<string> {
     const subscriptionId = generateId('sub');
-    
+
     const subscription: TopicSubscription = {
       id: subscriptionId,
       topic,
@@ -470,7 +460,7 @@ export class MessageBus extends EventEmitter {
       filter: options.filter,
       ackRequired: options.ackRequired || false,
       qos: options.qos || 0,
-      createdAt: new Date()
+      createdAt: new Date(),
     };
 
     this.subscriptions.set(subscriptionId, subscription);
@@ -479,7 +469,7 @@ export class MessageBus extends EventEmitter {
       subscriptionId,
       topic,
       subscriber: subscriber.id,
-      qos: subscription.qos
+      qos: subscription.qos,
     });
 
     this.emit('subscription:created', { subscription });
@@ -498,7 +488,7 @@ export class MessageBus extends EventEmitter {
     this.logger.info('Topic subscription removed', {
       subscriptionId,
       topic: subscription.topic,
-      subscriber: subscription.subscriber.id
+      subscriber: subscription.subscriber.id,
     });
 
     this.emit('subscription:removed', { subscription });
@@ -514,14 +504,14 @@ export class MessageBus extends EventEmitter {
       messageId,
       agentId,
       timestamp: new Date(),
-      status: 'acknowledged'
+      status: 'acknowledged',
     };
 
     this.acknowledgments.set(`${messageId}:${agentId.id}`, ack);
 
     this.logger.debug('Message acknowledged', {
       messageId,
-      agentId: agentId.id
+      agentId: agentId.id,
     });
 
     this.emit('message:acknowledged', { messageId, agentId });
@@ -535,10 +525,10 @@ export class MessageBus extends EventEmitter {
   async createChannel(
     name: string,
     type: ChannelType,
-    config: Partial<ChannelConfig> = {}
+    config: Partial<ChannelConfig> = {},
   ): Promise<string> {
     const channelId = generateId('channel');
-    
+
     const channel: MessageChannel = {
       id: channelId,
       name,
@@ -558,13 +548,13 @@ export class MessageBus extends EventEmitter {
           adminPermission: 'creator',
           allowedSenders: [],
           allowedReceivers: [],
-          bannedAgents: []
+          bannedAgents: [],
         },
-        ...config
+        ...config,
       },
       statistics: this.createChannelStatistics(),
       filters: [],
-      middleware: []
+      middleware: [],
     };
 
     this.channels.set(channelId, channel);
@@ -573,7 +563,7 @@ export class MessageBus extends EventEmitter {
       channelId,
       name,
       type,
-      config: channel.config
+      config: channel.config,
     });
 
     this.emit('channel:created', { channel });
@@ -598,7 +588,7 @@ export class MessageBus extends EventEmitter {
     }
 
     // Add participant if not already present
-    if (!channel.participants.some(p => p.id === agentId.id)) {
+    if (!channel.participants.some((p) => p.id === agentId.id)) {
       channel.participants.push(agentId);
       channel.statistics.participantCount = channel.participants.length;
     }
@@ -606,7 +596,7 @@ export class MessageBus extends EventEmitter {
     this.logger.info('Agent joined channel', {
       channelId,
       agentId: agentId.id,
-      participantCount: channel.participants.length
+      participantCount: channel.participants.length,
     });
 
     this.emit('channel:joined', { channelId, agentId });
@@ -619,13 +609,13 @@ export class MessageBus extends EventEmitter {
     }
 
     // Remove participant
-    channel.participants = channel.participants.filter(p => p.id !== agentId.id);
+    channel.participants = channel.participants.filter((p) => p.id !== agentId.id);
     channel.statistics.participantCount = channel.participants.length;
 
     this.logger.info('Agent left channel', {
       channelId,
       agentId: agentId.id,
-      participantCount: channel.participants.length
+      participantCount: channel.participants.length,
     });
 
     this.emit('channel:left', { channelId, agentId });
@@ -636,10 +626,10 @@ export class MessageBus extends EventEmitter {
   async createQueue(
     name: string,
     type: QueueType,
-    config: Partial<QueueConfig> = {}
+    config: Partial<QueueConfig> = {},
   ): Promise<string> {
     const queueId = generateId('queue');
-    
+
     const queue: MessageQueue = {
       id: queueId,
       name,
@@ -656,12 +646,12 @@ export class MessageBus extends EventEmitter {
           initialDelay: 1000,
           maxDelay: 30000,
           backoffMultiplier: this.config.backoffMultiplier,
-          jitter: true
+          jitter: true,
         },
-        ...config
+        ...config,
       },
       subscribers: [],
-      statistics: this.createQueueStatistics()
+      statistics: this.createQueueStatistics(),
     };
 
     this.queues.set(queueId, queue);
@@ -670,7 +660,7 @@ export class MessageBus extends EventEmitter {
       queueId,
       name,
       type,
-      config: queue.config
+      config: queue.config,
     });
 
     this.emit('queue:created', { queue });
@@ -703,7 +693,7 @@ export class MessageBus extends EventEmitter {
     this.logger.debug('Message enqueued', {
       queueId,
       messageId: message.id,
-      queueDepth: queue.messages.length
+      queueDepth: queue.messages.length,
     });
 
     this.emit('message:enqueued', { queueId, message });
@@ -718,7 +708,7 @@ export class MessageBus extends EventEmitter {
       throw new Error(`Queue ${queueId} not found`);
     }
 
-    const subscriber = queue.subscribers.find(s => s.id === subscriberId);
+    const subscriber = queue.subscribers.find((s) => s.id === subscriberId);
     if (!subscriber) {
       throw new Error(`Subscriber ${subscriberId} not found in queue ${queueId}`);
     }
@@ -729,7 +719,7 @@ export class MessageBus extends EventEmitter {
 
     for (let i = 0; i < queue.messages.length; i++) {
       const msg = queue.messages[i];
-      
+
       // Check if message matches subscriber filter
       if (subscriber.filter && !this.matchesFilter(msg, subscriber.filter)) {
         continue;
@@ -757,7 +747,7 @@ export class MessageBus extends EventEmitter {
       queueId,
       messageId: message.id,
       subscriberId,
-      queueDepth: queue.messages.length
+      queueDepth: queue.messages.length,
     });
 
     this.emit('message:dequeued', { queueId, message, subscriberId });
@@ -770,7 +760,7 @@ export class MessageBus extends EventEmitter {
   private async routeMessage(message: Message, preferredChannel?: string): Promise<void> {
     // Apply routing rules
     const route = await this.router.calculateRoute(message, preferredChannel);
-    
+
     // Update message route
     message.metadata.route = [...(message.metadata.route || []), ...route.hops];
 
@@ -784,10 +774,9 @@ export class MessageBus extends EventEmitter {
     try {
       await this.deliveryManager.deliver(message, target);
       this.metrics.recordDeliverySuccess(message);
-      
     } catch (error) {
       this.metrics.recordDeliveryFailure(message);
-      
+
       // Handle delivery failure based on reliability level
       if (message.reliability !== 'best-effort') {
         await this.retryManager.scheduleRetry(message, target, error);
@@ -799,7 +788,9 @@ export class MessageBus extends EventEmitter {
 
   private validateMessage(message: Message): void {
     if (message.metadata.size > this.config.maxMessageSize) {
-      throw new Error(`Message size ${message.metadata.size} exceeds limit ${this.config.maxMessageSize}`);
+      throw new Error(
+        `Message size ${message.metadata.size} exceeds limit ${this.config.maxMessageSize}`,
+      );
     }
 
     if (message.expiresAt && message.expiresAt <= new Date()) {
@@ -841,7 +832,7 @@ export class MessageBus extends EventEmitter {
   private async filterReceivers(
     receivers: AgentId[],
     filter: MessageFilter,
-    context: any
+    context: any,
   ): Promise<AgentId[]> {
     // Placeholder for receiver filtering logic
     return receivers;
@@ -849,22 +840,22 @@ export class MessageBus extends EventEmitter {
 
   private canJoinChannel(channel: MessageChannel, agentId: AgentId): boolean {
     const acl = channel.config.accessControl;
-    
+
     // Check banned list
-    if (acl.bannedAgents.some(banned => banned.id === agentId.id)) {
+    if (acl.bannedAgents.some((banned) => banned.id === agentId.id)) {
       return false;
     }
 
     // Check allowed list (if specified)
     if (acl.allowedSenders.length > 0) {
-      return acl.allowedSenders.some(allowed => allowed.id === agentId.id);
+      return acl.allowedSenders.some((allowed) => allowed.id === agentId.id);
     }
 
     return true;
   }
 
   private matchesFilter(message: Message, filter: MessageFilter): boolean {
-    return filter.conditions.every(condition => {
+    return filter.conditions.every((condition) => {
       const fieldValue = this.getFieldValue(message, condition.field);
       return this.evaluateCondition(fieldValue, condition.operator, condition.value);
     });
@@ -873,24 +864,32 @@ export class MessageBus extends EventEmitter {
   private getFieldValue(message: Message, field: string): any {
     const parts = field.split('.');
     let value: any = message;
-    
+
     for (const part of parts) {
       value = value?.[part];
     }
-    
+
     return value;
   }
 
   private evaluateCondition(fieldValue: any, operator: string, compareValue: any): boolean {
     switch (operator) {
-      case 'eq': return fieldValue === compareValue;
-      case 'ne': return fieldValue !== compareValue;
-      case 'gt': return fieldValue > compareValue;
-      case 'lt': return fieldValue < compareValue;
-      case 'contains': return String(fieldValue).includes(String(compareValue));
-      case 'matches': return new RegExp(compareValue).test(String(fieldValue));
-      case 'in': return Array.isArray(compareValue) && compareValue.includes(fieldValue);
-      default: return false;
+      case 'eq':
+        return fieldValue === compareValue;
+      case 'ne':
+        return fieldValue !== compareValue;
+      case 'gt':
+        return fieldValue > compareValue;
+      case 'lt':
+        return fieldValue < compareValue;
+      case 'contains':
+        return String(fieldValue).includes(String(compareValue));
+      case 'matches':
+        return new RegExp(compareValue).test(String(fieldValue));
+      case 'in':
+        return Array.isArray(compareValue) && compareValue.includes(fieldValue);
+      default:
+        return false;
     }
   }
 
@@ -914,9 +913,9 @@ export class MessageBus extends EventEmitter {
   }
 
   private insertByPriority(messages: Message[], message: Message): void {
-    const priorityOrder = { 'critical': 0, 'high': 1, 'normal': 2, 'low': 3 };
+    const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
     const messagePriority = priorityOrder[message.priority];
-    
+
     let insertIndex = messages.length;
     for (let i = 0; i < messages.length; i++) {
       const currentPriority = priorityOrder[messages[i].priority];
@@ -925,13 +924,13 @@ export class MessageBus extends EventEmitter {
         break;
       }
     }
-    
+
     messages.splice(insertIndex, 0, message);
   }
 
   private insertByTimestamp(messages: Message[], message: Message): void {
     const targetTime = message.expiresAt || message.timestamp;
-    
+
     let insertIndex = messages.length;
     for (let i = 0; i < messages.length; i++) {
       const currentTime = messages[i].expiresAt || messages[i].timestamp;
@@ -940,7 +939,7 @@ export class MessageBus extends EventEmitter {
         break;
       }
     }
-    
+
     messages.splice(insertIndex, 0, message);
   }
 
@@ -952,46 +951,48 @@ export class MessageBus extends EventEmitter {
         for (let i = 0; i < subscriber.prefetchCount; i++) {
           const message = await this.dequeueMessage(queue.id, subscriber.id);
           if (!message) break;
-          
+
           await this.deliverMessageToSubscriber(message, subscriber);
         }
       }
     }
   }
 
-  private async deliverMessageToSubscriber(message: Message, subscriber: QueueSubscriber): Promise<void> {
+  private async deliverMessageToSubscriber(
+    message: Message,
+    subscriber: QueueSubscriber,
+  ): Promise<void> {
     try {
       // Deliver message to subscriber
       this.emit('message:delivered', {
         message,
-        subscriber: subscriber.agent
+        subscriber: subscriber.agent,
       });
 
       // Handle acknowledgment if required
       if (subscriber.ackMode === 'auto') {
         await this.acknowledgeMessage(message.id, subscriber.agent);
       }
-
     } catch (error) {
       this.logger.error('Failed to deliver message to subscriber', {
         messageId: message.id,
         subscriberId: subscriber.id,
-        error
+        error,
       });
     }
   }
 
   private checkAllAcknowledgments(message: Message): void {
     const requiredAcks = message.receivers.length;
-    const receivedAcks = message.receivers.filter(receiver =>
-      this.acknowledgments.has(`${message.id}:${receiver.id}`)
+    const receivedAcks = message.receivers.filter((receiver) =>
+      this.acknowledgments.has(`${message.id}:${receiver.id}`),
     ).length;
 
     if (receivedAcks === requiredAcks) {
       this.emit('message:fully-acknowledged', { message });
-      
+
       // Clean up acknowledgments
-      message.receivers.forEach(receiver => {
+      message.receivers.forEach((receiver) => {
         this.acknowledgments.delete(`${message.id}:${receiver.id}`);
       });
     }
@@ -1002,26 +1003,25 @@ export class MessageBus extends EventEmitter {
     await this.createChannel('system-broadcast', 'broadcast', {
       persistent: true,
       reliable: true,
-      maxParticipants: 10000
+      maxParticipants: 10000,
     });
 
     // Agent coordination channel
     await this.createChannel('agent-coordination', 'multicast', {
       persistent: true,
       reliable: true,
-      ordered: true
+      ordered: true,
     });
 
     // Task distribution channel
     await this.createChannel('task-distribution', 'topic', {
       persistent: true,
-      reliable: false
+      reliable: false,
     });
   }
 
   private getDefaultBroadcastChannel(): MessageChannel | undefined {
-    return Array.from(this.channels.values())
-      .find(channel => channel.type === 'broadcast');
+    return Array.from(this.channels.values()).find((channel) => channel.type === 'broadcast');
   }
 
   private createChannelStatistics(): ChannelStatistics {
@@ -1034,7 +1034,7 @@ export class MessageBus extends EventEmitter {
       throughput: 0,
       errorRate: 0,
       participantCount: 0,
-      lastActivity: new Date()
+      lastActivity: new Date(),
     };
   }
 
@@ -1046,7 +1046,7 @@ export class MessageBus extends EventEmitter {
       throughput: 0,
       averageWaitTime: 0,
       subscriberCount: 0,
-      deadLetterCount: 0
+      deadLetterCount: 0,
     };
   }
 
@@ -1089,10 +1089,10 @@ export class MessageBus extends EventEmitter {
 
   private handleAgentDisconnected(agentId: AgentId): void {
     this.logger.info('Agent disconnected from message bus', { agentId: agentId.id });
-    
+
     // Remove from all channels
     for (const channel of this.channels.values()) {
-      channel.participants = channel.participants.filter(p => p.id !== agentId.id);
+      channel.participants = channel.participants.filter((p) => p.id !== agentId.id);
     }
 
     // Remove subscriptions
@@ -1116,26 +1116,29 @@ export class MessageBus extends EventEmitter {
   private handleRetryExhausted(data: any): void {
     this.logger.error('Message delivery retry exhausted', {
       messageId: data.message.id,
-      target: data.target
+      target: data.target,
     });
 
     // Send to dead letter queue if configured
     this.sendToDeadLetterQueue('system-dlq', data.message, 'retry_exhausted');
   }
 
-  private async sendToDeadLetterQueue(queueId: string, message: Message, reason: string): Promise<void> {
+  private async sendToDeadLetterQueue(
+    queueId: string,
+    message: Message,
+    reason: string,
+  ): Promise<void> {
     try {
       message.metadata.deadLetterReason = reason;
       message.metadata.deadLetterTimestamp = new Date();
-      
+
       await this.enqueueMessage(queueId, message);
-      
     } catch (error) {
       this.logger.error('Failed to send message to dead letter queue', {
         messageId: message.id,
         queueId,
         reason,
-        error
+        error,
       });
     }
   }
@@ -1189,7 +1192,7 @@ export class MessageBus extends EventEmitter {
       storedMessages: this.messageStore.size,
       deliveryReceipts: this.deliveryReceipts.size,
       acknowledgments: this.acknowledgments.size,
-      busMetrics: this.metrics.getMetrics()
+      busMetrics: this.metrics.getMetrics(),
     };
   }
 
@@ -1249,7 +1252,10 @@ interface RouteResult {
 }
 
 class MessageRouter {
-  constructor(private config: MessageBusConfig, private logger: ILogger) {}
+  constructor(
+    private config: MessageBusConfig,
+    private logger: ILogger,
+  ) {}
 
   async initialize(): Promise<void> {
     this.logger.debug('Message router initialized');
@@ -1267,7 +1273,7 @@ class MessageRouter {
     for (const receiver of message.receivers) {
       targets.push({
         type: 'agent',
-        id: receiver.id
+        id: receiver.id,
       });
       hops.push(receiver.id);
     }
@@ -1275,13 +1281,16 @@ class MessageRouter {
     return {
       targets,
       hops,
-      cost: targets.length
+      cost: targets.length,
     };
   }
 }
 
 class DeliveryManager extends EventEmitter {
-  constructor(private config: MessageBusConfig, private logger: ILogger) {
+  constructor(
+    private config: MessageBusConfig,
+    private logger: ILogger,
+  ) {
     super();
   }
 
@@ -1298,7 +1307,7 @@ class DeliveryManager extends EventEmitter {
     this.logger.debug('Delivering message', {
       messageId: message.id,
       target: target.id,
-      type: target.type
+      type: target.type,
     });
 
     // Emit delivery success
@@ -1310,7 +1319,10 @@ class RetryManager extends EventEmitter {
   private retryQueue: Array<{ message: Message; target: DeliveryTarget; attempts: number }> = [];
   private retryInterval?: NodeJS.Timeout;
 
-  constructor(private config: MessageBusConfig, private logger: ILogger) {
+  constructor(
+    private config: MessageBusConfig,
+    private logger: ILogger,
+  ) {
     super();
   }
 
@@ -1327,8 +1339,8 @@ class RetryManager extends EventEmitter {
   }
 
   async scheduleRetry(message: Message, target: DeliveryTarget, error: any): Promise<void> {
-    const existingEntry = this.retryQueue.find(entry =>
-      entry.message.id === message.id && entry.target.id === target.id
+    const existingEntry = this.retryQueue.find(
+      (entry) => entry.message.id === message.id && entry.target.id === target.id,
     );
 
     if (existingEntry) {
@@ -1340,7 +1352,7 @@ class RetryManager extends EventEmitter {
     this.logger.debug('Retry scheduled', {
       messageId: message.id,
       target: target.id,
-      error: (error instanceof Error ? error.message : String(error))
+      error: error instanceof Error ? error.message : String(error),
     });
   }
 
@@ -1352,7 +1364,7 @@ class RetryManager extends EventEmitter {
 
   private async processRetries(): Promise<void> {
     const now = Date.now();
-    const toRetry = this.retryQueue.filter(entry => {
+    const toRetry = this.retryQueue.filter((entry) => {
       const delay = this.calculateDelay(entry.attempts);
       return now >= entry.message.timestamp.getTime() + delay;
     });
@@ -1360,7 +1372,7 @@ class RetryManager extends EventEmitter {
     for (const entry of toRetry) {
       if (entry.attempts >= this.config.retryAttempts) {
         // Remove from retry queue and emit exhausted event
-        this.retryQueue = this.retryQueue.filter(r => r !== entry);
+        this.retryQueue = this.retryQueue.filter((r) => r !== entry);
         this.emit('retry:exhausted', entry);
       } else {
         // Retry delivery
@@ -1368,18 +1380,17 @@ class RetryManager extends EventEmitter {
           // Simulate retry delivery
           this.logger.debug('Retrying message delivery', {
             messageId: entry.message.id,
-            attempt: entry.attempts
+            attempt: entry.attempts,
           });
-          
+
           // Remove from retry queue on success
-          this.retryQueue = this.retryQueue.filter(r => r !== entry);
-          
+          this.retryQueue = this.retryQueue.filter((r) => r !== entry);
         } catch (error) {
           // Keep in retry queue for next attempt
           this.logger.warn('Retry attempt failed', {
             messageId: entry.message.id,
             attempt: entry.attempts,
-            error: (error instanceof Error ? error.message : String(error))
+            error: error instanceof Error ? error.message : String(error),
           });
         }
       }
@@ -1390,7 +1401,7 @@ class RetryManager extends EventEmitter {
     const baseDelay = 1000; // 1 second
     return Math.min(
       baseDelay * Math.pow(this.config.backoffMultiplier, attempts - 1),
-      30000 // Max 30 seconds
+      30000, // Max 30 seconds
     );
   }
 }
@@ -1411,7 +1422,7 @@ class MessageBusMetrics {
     this.messagesDelivered++;
     const latency = Date.now() - message.timestamp.getTime();
     this.deliveryLatencies.push(latency);
-    
+
     // Keep only last 1000 latencies
     if (this.deliveryLatencies.length > 1000) {
       this.deliveryLatencies.shift();
@@ -1423,8 +1434,10 @@ class MessageBusMetrics {
   }
 
   getMetrics(): any {
-    const avgLatency = this.deliveryLatencies.length > 0 ?
-      this.deliveryLatencies.reduce((sum, lat) => sum + lat, 0) / this.deliveryLatencies.length : 0;
+    const avgLatency =
+      this.deliveryLatencies.length > 0
+        ? this.deliveryLatencies.reduce((sum, lat) => sum + lat, 0) / this.deliveryLatencies.length
+        : 0;
 
     return {
       messagesSent: this.messagesSent,
@@ -1432,7 +1445,7 @@ class MessageBusMetrics {
       messagesFailed: this.messagesFailed,
       bytesTransferred: this.bytesTransferred,
       averageLatency: avgLatency,
-      successRate: this.messagesSent > 0 ? (this.messagesDelivered / this.messagesSent) * 100 : 100
+      successRate: this.messagesSent > 0 ? (this.messagesDelivered / this.messagesSent) * 100 : 100,
     };
   }
-}
+}