onbuzz 3.6.1 → 3.6.2

package/src/tools/__tests__/agentCommunicationTool.test.js

@@ -0,0 +1,500 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs (promises) and crypto BEFORE importing the tool
+const fsMock = {
+  mkdir: jest.fn().mockResolvedValue(undefined),
+  readFile: jest.fn().mockResolvedValue('{}'),
+  writeFile: jest.fn().mockResolvedValue(undefined),
+  stat: jest.fn().mockResolvedValue({ size: 100 }),
+  copyFile: jest.fn().mockResolvedValue(undefined),
+  access: jest.fn().mockResolvedValue(undefined)
+};
+
+jest.unstable_mockModule('fs', () => ({
+  default: { promises: fsMock },
+  promises: fsMock
+}));
+
+jest.unstable_mockModule('crypto', () => ({
+  default: {
+    randomUUID: jest.fn(() => 'mock-crypto-uuid'),
+    randomBytes: jest.fn(() => ({ toString: () => 'mockrandom' }))
+  }
+}));
+
+const { default: AgentCommunicationTool } = await import('../agentCommunicationTool.js');
+
+/**
+ * Helper: builds a tool, agent pool, and context for tests.
+ */
+function createTestSetup() {
+  const logger = createMockLogger();
+  const tool = new AgentCommunicationTool({ storageDir: '/tmp/msg-test' });
+  tool.logger = logger;
+
+  const senderAgent = {
+    id: 'agent-sender',
+    name: 'Sender Agent',
+    type: 'developer',
+    capabilities: ['code'],
+    status: 'active',
+    isPaused: false,
+    conversations: { full: { messages: [], lastUpdated: '' } },
+    currentModel: null
+  };
+
+  const recipientAgent = {
+    id: 'agent-recipient',
+    name: 'Recipient Agent',
+    type: 'reviewer',
+    capabilities: ['review'],
+    status: 'active',
+    isPaused: false,
+    conversations: { full: { messages: [], lastUpdated: '' } },
+    currentModel: null
+  };
+
+  const agents = new Map();
+  agents.set('agent-sender', senderAgent);
+  agents.set('agent-recipient', recipientAgent);
+
+  const agentPool = {
+    getAgent: jest.fn((id) => Promise.resolve(agents.get(id) || null)),
+    listActiveAgents: jest.fn().mockResolvedValue([senderAgent, recipientAgent]),
+    notifyAgent: jest.fn().mockResolvedValue(undefined),
+    persistAgentState: jest.fn().mockResolvedValue(undefined),
+    updateAgent: jest.fn().mockResolvedValue(undefined),
+    addInterAgentMessage: jest.fn().mockResolvedValue(undefined)
+  };
+
+  const context = {
+    agentId: 'agent-sender',
+    agentPool,
+    projectDir: '/tmp/test'
+  };
+
+  return { tool, senderAgent, recipientAgent, agentPool, context, logger };
+}
+
+describe('AgentCommunicationTool', () => {
+  // ── constructor ─────────────────────────────────────────────────
+  describe('constructor', () => {
+    test('initializes with default config values', () => {
+      const tool = new AgentCommunicationTool();
+      expect(tool.config.maxConversationDepth).toBe(10);
+      expect(tool.config.maxRecipientsPerMessage).toBe(3);
+      expect(tool.messages).toBeInstanceOf(Map);
+      expect(tool.conversations).toBeInstanceOf(Map);
+    });
+
+    test('accepts custom config overrides', () => {
+      const tool = new AgentCommunicationTool({ maxConversationDepth: 5 });
+      expect(tool.config.maxConversationDepth).toBe(5);
+    });
+  });
+
+  // ── getDescription ──────────────────────────────────────────────
+  describe('getDescription', () => {
+    test('returns description with action list', () => {
+      const tool = new AgentCommunicationTool();
+      const desc = tool.getDescription();
+      expect(desc).toContain('get-available-agents');
+      expect(desc).toContain('send-message');
+      expect(desc).toContain('reply-to-message');
+    });
+  });
+
+  // ── parseParameters ─────────────────────────────────────────────
+  describe('parseParameters', () => {
+    test('parses object with actions array', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool.parseParameters({
+        actions: [{ type: 'get-available-agents' }]
+      });
+      expect(result.action).toBe('get-available-agents');
+    });
+
+    test('parses object with action field', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool.parseParameters({ action: 'send-message', subject: 'Hi' });
+      expect(result.action).toBe('send-message');
+    });
+
+    test('parses JSON string', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool.parseParameters('{"action": "get-available-agents"}');
+      expect(result.action).toBe('get-available-agents');
+    });
+
+    test('parses XML-style content', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool.parseParameters('<action>send-message</action><subject>Hello</subject>');
+      expect(result.action).toBe('send-message');
+      expect(result.subject).toBe('Hello');
+    });
+
+    test('returns empty object for null input', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool.parseParameters(null);
+      expect(result).toEqual({});
+    });
+  });
+
+  // ── execute - missing action ────────────────────────────────────
+  describe('execute - missing params', () => {
+    test('throws when action is missing', async () => {
+      const { tool, context } = createTestSetup();
+      await expect(tool.execute({}, context)).rejects.toThrow('Action parameter is required');
+    });
+
+    test('throws when agentId is missing from context', async () => {
+      const { tool } = createTestSetup();
+      await expect(tool.execute({ action: 'get-available-agents' }, {}))
+        .rejects.toThrow('Agent ID is required');
+    });
+
+    test('throws for unknown action', async () => {
+      const { tool, context } = createTestSetup();
+      await expect(tool.execute({ action: 'teleport' }, context))
+        .rejects.toThrow('Unknown action');
+    });
+  });
+
+  // ── get-available-agents ────────────────────────────────────────
+  describe('execute - get-available-agents', () => {
+    test('returns list excluding requesting agent', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({ action: 'get-available-agents' }, context);
+      expect(result.success).toBe(true);
+      expect(result.agents).toHaveLength(1);
+      expect(result.agents[0].id).toBe('agent-recipient');
+    });
+
+    test('includes message stats for each agent', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({ action: 'get-available-agents' }, context);
+      expect(result.agents[0].messageStats).toBeDefined();
+    });
+
+    test('returns error when agentPool missing', async () => {
+      const { tool } = createTestSetup();
+      const result = await tool.execute(
+        { action: 'get-available-agents' },
+        { agentId: 'agent-sender', agentPool: null }
+      );
+      // Should catch internally and return success: false
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  // ── send-message ────────────────────────────────────────────────
+  describe('execute - send-message', () => {
+    test('sends message to recipient successfully', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Review code',
+        message: 'Please review the auth module'
+      }, context);
+      expect(result.success).toBe(true);
+      expect(result.messageId).toBeDefined();
+      expect(result.conversationId).toBeDefined();
+      expect(result.recipients).toContain('agent-recipient');
+    });
+
+    test('errors when subject is missing', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        message: 'No subject'
+      }, context);
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Subject and message are required');
+    });
+
+    test('errors when message is missing', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'No body'
+      }, context);
+      expect(result.success).toBe(false);
+    });
+
+    test('errors when no recipient provided', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({
+        action: 'send-message',
+        subject: 'Test',
+        message: 'Hello'
+      }, context);
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('At least one recipient');
+    });
+
+    test('returns suggestions when recipient not found', async () => {
+      const { tool, context, agentPool } = createTestSetup();
+      // Mock _canSendMessage to allow (bypass delay check)
+      tool._canSendMessage = jest.fn().mockResolvedValue({ allowed: true });
+      const result = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-nonexistent',
+        subject: 'Test',
+        message: 'Hello'
+      }, context);
+      expect(result.success).toBe(false);
+      expect(result.suggestion).toBeDefined();
+    });
+
+    test('updates message counts after sending', async () => {
+      const { tool, context } = createTestSetup();
+      await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Test',
+        message: 'Content'
+      }, context);
+      const senderStats = tool.agentMessageCounts.get('agent-sender');
+      expect(senderStats.sent).toBe(1);
+    });
+  });
+
+  // ── reply-to-message ────────────────────────────────────────────
+  describe('execute - reply-to-message', () => {
+    test('replies to an existing message', async () => {
+      const { tool, context } = createTestSetup();
+      // Send initial message
+      const sendResult = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Question',
+        message: 'What is the status?'
+      }, context);
+      const msgId = sendResult.messageId;
+
+      // Reply as recipient
+      const replyResult = await tool.execute({
+        action: 'reply-to-message',
+        'message-id': msgId,
+        message: 'All good!'
+      }, { agentId: 'agent-recipient', agentPool: context.agentPool });
+      expect(replyResult.success).toBe(true);
+      expect(replyResult.depth).toBe(1);
+    });
+
+    test('errors when original message ID missing', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({
+        action: 'reply-to-message',
+        message: 'Reply without ID'
+      }, context);
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Original message ID and reply content are required');
+    });
+
+    test('errors when original message not found', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({
+        action: 'reply-to-message',
+        'message-id': 'msg-nonexistent',
+        message: 'Reply'
+      }, context);
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Original message not found');
+    });
+
+    test('errors when sender is not a participant', async () => {
+      const { tool, context, agentPool } = createTestSetup();
+      // Send message between sender and recipient
+      const sendResult = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Private',
+        message: 'Secret'
+      }, context);
+
+      // Try to reply as an outsider
+      const outsider = {
+        id: 'agent-outsider', name: 'Outsider', conversations: { full: { messages: [] } }
+      };
+      agentPool.getAgent.mockImplementation((id) => {
+        if (id === 'agent-outsider') return Promise.resolve(outsider);
+        if (id === 'agent-sender') return Promise.resolve(context.agentPool);
+        return Promise.resolve(null);
+      });
+
+      const result = await tool.execute({
+        action: 'reply-to-message',
+        'message-id': sendResult.messageId,
+        message: 'Eavesdrop'
+      }, { agentId: 'agent-outsider', agentPool });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not a participant');
+    });
+
+    test('rejects reply when conversation depth limit reached', async () => {
+      const { tool, context } = createTestSetup();
+      tool.config.maxConversationDepth = 1;
+
+      const sendResult = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Deep',
+        message: 'Start'
+      }, context);
+
+      // First reply (depth 1) - should succeed
+      const reply1 = await tool.execute({
+        action: 'reply-to-message',
+        'message-id': sendResult.messageId,
+        message: 'Reply 1'
+      }, { agentId: 'agent-recipient', agentPool: context.agentPool });
+      expect(reply1.success).toBe(true);
+
+      // Second reply (depth 2) should fail at depth limit 1
+      const reply2 = await tool.execute({
+        action: 'reply-to-message',
+        'message-id': reply1.messageId,
+        message: 'Reply 2'
+      }, context);
+      expect(reply2.success).toBe(false);
+      expect(reply2.error).toContain('depth limit');
+    });
+  });
+
+  // ── get-unreplied-messages ──────────────────────────────────────
+  describe('execute - get-unreplied-messages', () => {
+    test('returns unreplied messages for agent', async () => {
+      const { tool, context } = createTestSetup();
+      // Send message requiring reply
+      await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Need reply',
+        message: 'Please respond',
+        'requires-reply': true
+      }, context);
+
+      const result = await tool.execute(
+        { action: 'get-unreplied-messages' },
+        { agentId: 'agent-recipient', agentPool: context.agentPool }
+      );
+      expect(result.success).toBe(true);
+      expect(result.messages.length).toBeGreaterThan(0);
+      expect(result.messages[0].subject).toBe('Need reply');
+    });
+
+    test('returns empty list when no messages', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute(
+        { action: 'get-unreplied-messages' },
+        { agentId: 'agent-recipient', agentPool: context.agentPool }
+      );
+      expect(result.success).toBe(true);
+      expect(result.messages).toHaveLength(0);
+    });
+  });
+
+  // ── mark-conversation-ended ─────────────────────────────────────
+  describe('execute - mark-conversation-ended', () => {
+    test('ends a conversation successfully', async () => {
+      const { tool, context } = createTestSetup();
+      const sendResult = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'End me',
+        message: 'Done'
+      }, context);
+
+      const result = await tool.execute({
+        action: 'mark-conversation-ended',
+        'conversation-id': sendResult.conversationId,
+        reason: 'Work complete'
+      }, context);
+      expect(result.success).toBe(true);
+      expect(result.status).toBe('ended');
+    });
+
+    test('errors when conversation-id is missing', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute(
+        { action: 'mark-conversation-ended' }, context
+      );
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Conversation ID is required');
+    });
+
+    test('errors for non-existent conversation', async () => {
+      const { tool, context } = createTestSetup();
+      const result = await tool.execute({
+        action: 'mark-conversation-ended',
+        'conversation-id': 'conv-nope'
+      }, context);
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Conversation not found');
+    });
+
+    test('errors when agent is not a participant', async () => {
+      const { tool, context, agentPool } = createTestSetup();
+      const sendResult = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Private',
+        message: 'Content'
+      }, context);
+
+      const result = await tool.execute({
+        action: 'mark-conversation-ended',
+        'conversation-id': sendResult.conversationId
+      }, { agentId: 'agent-outsider', agentPool });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not a participant');
+    });
+  });
+
+  // ── helper methods ──────────────────────────────────────────────
+  describe('_parseRecipients', () => {
+    test('parses single recipient string', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool._parseRecipients('agent-1', null);
+      expect(result).toEqual(['agent-1']);
+    });
+
+    test('parses JSON array of recipients', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool._parseRecipients(null, '["agent-1", "agent-2"]');
+      expect(result).toEqual(['agent-1', 'agent-2']);
+    });
+
+    test('handles array recipients directly', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool._parseRecipients(null, ['agent-1', 'agent-2']);
+      expect(result).toEqual(['agent-1', 'agent-2']);
+    });
+
+    test('deduplicates recipients', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool._parseRecipients('agent-1', ['agent-1', 'agent-2']);
+      expect(result).toEqual(['agent-1', 'agent-2']);
+    });
+
+    test('handles non-JSON string as single recipient', () => {
+      const tool = new AgentCommunicationTool();
+      const result = tool._parseRecipients(null, 'plain-id');
+      expect(result).toEqual(['plain-id']);
+    });
+  });
+
+  describe('_processAttachments', () => {
+    test('returns empty array for null/undefined', async () => {
+      const tool = new AgentCommunicationTool();
+      expect(await tool._processAttachments(null, 'agent-1')).toEqual([]);
+      expect(await tool._processAttachments(undefined, 'agent-1')).toEqual([]);
+    });
+  });
+});