🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
fix(swarm): track acknowledgements per recipient (#4234)
Rudy Mizrahi Celekli56da07418187
diff --git a/v3/@claude-flow/swarm/__tests__/message-bus.recipient-ack.test.ts b/v3/@claude-flow/swarm/__tests__/message-bus.recipient-ack.test.tsnew file mode 100644index 0000000000..0b8293b2b3--- /dev/null+++ b/v3/@claude-flow/swarm/__tests__/message-bus.recipient-ack.test.ts@@ -0,0 +1,80 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import { createMessageBus, type MessageBus } from '../src/message-bus.js';++let bus: MessageBus;+const message = {+ type: 'direct' as const, from: 'sender', payload: {},+ priority: 'normal' as const, requiresAck: true, ttlMs: 60_000,+};+const ack = (messageId: string, from: string) => ({+ messageId, from, received: true, processedAt: new Date(),+});++beforeEach(async () => {+ vi.useFakeTimers();+ bus = createMessageBus({ ackTimeoutMs: 100, processingIntervalMs: 5000 });+ await bus.initialize();+});+afterEach(async () => {+ await bus.shutdown();+ vi.useRealTimers();+});++describe('MessageBus recipient acknowledgement tracking', () => {+ it('allows every broadcast recipient to acknowledge without orphaned timeouts', async () => {+ const timeouts = vi.fn();+ bus.on('message.ack_timeout', timeouts);+ bus.subscribe('first', (received) => { void bus.acknowledge(ack(received.id, 'first')); });+ bus.subscribe('second', (received) => { void bus.acknowledge(ack(received.id, 'second')); });+ await bus.broadcast(message);+ await vi.advanceTimersByTimeAsync(150);+ expect(timeouts).not.toHaveBeenCalled();+ expect(bus.getStats().ackRate).toBe(1);+ });++ it('does not accept an acknowledgement from another agent', async () => {+ const timeouts = vi.fn();+ bus.on('message.ack_timeout', timeouts);+ bus.subscribe('target', (received) => { void bus.acknowledge(ack(received.id, 'other')); });+ await bus.send({ ...message, to: 'target' });+ await vi.advanceTimersByTimeAsync(150);+ expect(timeouts).toHaveBeenCalledTimes(1);+ });++ it('retains the other broadcast recipient timeout after one acknowledges', async () => {+ const timeouts = vi.fn();+ bus.on('message.ack_timeout', timeouts);+ bus.subscribe('first', (received) => { void bus.acknowledge(ack(received.id, 'first')); });+ bus.subscribe('second', () => {});+ await bus.broadcast(message);+ await vi.advanceTimersByTimeAsync(150);+ expect(timeouts).toHaveBeenCalledTimes(1);+ expect(bus.getStats().ackRate).toBe(0.99);+ });++ it('clears every broadcast recipient timeout at shutdown', async () => {+ const timeouts = vi.fn();+ bus.on('message.ack_timeout', timeouts);+ bus.subscribe('first', () => {});+ bus.subscribe('second', () => {});+ await bus.broadcast(message);+ await vi.advanceTimersByTimeAsync(5);+ await bus.shutdown();+ await vi.advanceTimersByTimeAsync(150);+ expect(timeouts).not.toHaveBeenCalled();+ });++ it('clears the failed delivery attempt timeout before a successful retry', async () => {+ const timeouts = vi.fn();+ bus.on('message.ack_timeout', timeouts);+ let attempts = 0;+ bus.subscribe('target', (received) => {+ if (++attempts === 1) throw new Error('temporary subscriber failure');+ void bus.acknowledge(ack(received.id, 'target'));+ });+ await bus.send({ ...message, to: 'target' });+ await vi.advanceTimersByTimeAsync(150);+ expect(attempts).toBe(2);+ expect(timeouts).not.toHaveBeenCalled();+ });+});diff --git a/v3/@claude-flow/swarm/src/message-bus.ts b/v3/@claude-flow/swarm/src/message-bus.tsindex 910e2db8ca..fd2bc1fc1b 100644--- a/v3/@claude-flow/swarm/src/message-bus.ts+++ b/v3/@claude-flow/swarm/src/message-bus.ts@@ -425,13 +425,14 @@ export class MessageBus extends EventEmitter implements IMessageBus {}async acknowledge(ack: MessageAck): Promise<void> {- const pending = this.pendingAcks.get(ack.messageId);+ const key = this.ackKey(ack.messageId, ack.from);+ const pending = this.pendingAcks.get(key);if (!pending) {return;}clearTimeout(pending.timeout);- this.pendingAcks.delete(ack.messageId);+ this.pendingAcks.delete(key);if (!ack.received && ack.error) {this.handleAckFailure(pending.message, ack.error);@@ -443,6 +444,18 @@ export class MessageBus extends EventEmitter implements IMessageBus {});}+ private ackKey(messageId: string, recipient: string): string {+ // Broadcast recipients share a message ID, but acknowledge independently.+ return JSON.stringify([messageId, recipient]);+ }++ private clearPendingAck(messageId: string, recipient: string): void {+ const key = this.ackKey(messageId, recipient);+ const pending = this.pendingAcks.get(key);+ if (pending) clearTimeout(pending.timeout);+ this.pendingAcks.delete(key);+ }+private startProcessing(): void {// Dispatch is event-driven via scheduleProcessing() (triggered from// enqueue() and from retry re-queuing); this interval is only a@@ -537,11 +550,13 @@ export class MessageBus extends EventEmitter implements IMessageBus {try {// Set up ack timeout if requiredif (message.requiresAck) {+ const key = this.ackKey(message.id, subscription.agentId);+ this.clearPendingAck(message.id, subscription.agentId);const timeout = setTimeout(() => {- this.handleAckTimeout(message);+ this.handleAckTimeout(message, key);}, this.config.ackTimeoutMs);- this.pendingAcks.set(message.id, { message, timeout });+ this.pendingAcks.set(key, { message, timeout });}// Deliver asynchronously; shutdown owns and cancels pending handles.@@ -564,8 +579,8 @@ export class MessageBus extends EventEmitter implements IMessageBus {}}- private handleAckTimeout(message: Message): void {- this.pendingAcks.delete(message.id);+ private handleAckTimeout(message: Message, key: string): void {+ this.pendingAcks.delete(key);this.stats.ackRate = Math.max(0, this.stats.ackRate - 0.01);this.emit('message.ack_timeout', { messageId: message.id });}@@ -576,6 +591,8 @@ export class MessageBus extends EventEmitter implements IMessageBus {}private handleDeliveryError(message: Message, entry: MessageQueueEntry, error: Error, subscriberAgentId: string): void {+ // A failed callback never completed delivery; its retry owns a fresh timer.+ this.clearPendingAck(message.id, subscriberAgentId);entry.attempts++;entry.lastAttemptAt = new Date();