agenthub-multiagent-mcp 1.1.2 → 1.1.4

package/src/e2e.test.ts

@@ -1,298 +1,300 @@
-/**
- * End-to-end multi-agent communication tests
- *
- * These tests simulate real-world multi-agent scenarios:
- * - Multiple agents registering and communicating
- * - Channel-based group communication
- * - Message status tracking
- * - Agent coordination workflows
- *
- * Requires the AgentHub server to be running on localhost:8787
- */
-
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { ApiClient } from "./client.js";
-
-const TEST_URL = process.env.AGENTHUB_URL || "http://localhost:8787";
-const TEST_API_KEY = process.env.AGENTHUB_API_KEY || "test-key-123";
-
-describe("E2E: Multi-Agent Communication", () => {
-  let client: ApiClient;
-  const timestamp = Date.now();
-
-  // Create 3 agents for testing
-  const agents = {
-    coordinator: `coordinator-${timestamp}`,
-    backend: `backend-${timestamp}`,
-    frontend: `frontend-${timestamp}`,
-  };
-
-  beforeAll(async () => {
-    client = new ApiClient(TEST_URL, TEST_API_KEY);
-
-    // Register all agents
-    await client.registerAgent(agents.coordinator, "Coordinator Agent");
-    await client.registerAgent(agents.backend, "Backend Developer");
-    await client.registerAgent(agents.frontend, "Frontend Developer");
-  });
-
-  afterAll(async () => {
-    // Cleanup - disconnect all agents
-    for (const agentId of Object.values(agents)) {
-      try {
-        await client.disconnect(agentId);
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  });
-
-  describe("Scenario: Task Assignment Flow", () => {
-    let taskMessageId: string;
-    let responseMessageId: string;
-
-    it("step 1: coordinator assigns task to backend", async () => {
-      const result = await client.sendMessage({
-        from_agent: agents.coordinator,
-        to_agent: agents.backend,
-        type: "task",
-        subject: "Implement API endpoint",
-        body: "Please implement the /users endpoint with CRUD operations",
-        priority: "high",
-      });
-
-      expect(result.message_id).toBeDefined();
-      expect(result.status).toBe("pending");
-      taskMessageId = result.message_id;
-    });
-
-    it("step 2: backend receives task in inbox", async () => {
-      const inbox = await client.getInbox(agents.backend, false);
-
-      expect(inbox.total).toBeGreaterThan(0);
-      const taskMessage = inbox.messages.find((m) => m.id === taskMessageId);
-      expect(taskMessage).toBeDefined();
-      expect(taskMessage?.from_agent).toBe(agents.coordinator);
-      expect(taskMessage?.subject).toBe("Implement API endpoint");
-      expect(taskMessage?.type).toBe("task");
-      expect(taskMessage?.priority).toBe("high");
-    });
-
-    it("step 3: backend marks task as read", async () => {
-      // First deliver
-      await fetch(`${TEST_URL}/messages/${taskMessageId}/status`, {
-        method: "PATCH",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-Key": TEST_API_KEY,
-        },
-        body: JSON.stringify({ status: "delivered" }),
-      });
-
-      const result = await client.markRead(taskMessageId);
-      expect(result.updated).toBe(true);
-    });
-
-    it("step 4: backend starts work on the task", async () => {
-      const result = await client.startWork(
-        agents.backend,
-        "Implementing /users endpoint",
-        "API Development"
-      );
-
-      expect(result.acknowledged).toBe(true);
-    });
-
-    it("step 5: backend sends completion response", async () => {
-      const result = await client.reply(
-        taskMessageId,
-        agents.backend,
-        "Task completed. The /users endpoint is now live with full CRUD support."
-      );
-
-      expect(result.message_id).toBeDefined();
-      responseMessageId = result.message_id;
-    });
-
-    it("step 6: coordinator receives completion in inbox", async () => {
-      const inbox = await client.getInbox(agents.coordinator, false);
-
-      const responseMessage = inbox.messages.find((m) => m.id === responseMessageId);
-      expect(responseMessage).toBeDefined();
-      expect(responseMessage?.from_agent).toBe(agents.backend);
-      expect(responseMessage?.type).toBe("response");
-      expect(responseMessage?.reply_to).toBe(taskMessageId);
-    });
-  });
-
-  describe("Scenario: Broadcast Announcements", () => {
-    let broadcastId: string;
-
-    it("step 1: coordinator broadcasts announcement", async () => {
-      const result = await client.sendMessage({
-        from_agent: agents.coordinator,
-        broadcast: true,
-        type: "status",
-        subject: "Sprint Planning Meeting",
-        body: "Sprint planning in 30 minutes. Please prepare your updates.",
-      });
-
-      expect(result.message_id).toBeDefined();
-      broadcastId = result.message_id;
-    });
-
-    it("step 2: backend receives broadcast", async () => {
-      const inbox = await client.getInbox(agents.backend, false);
-
-      const broadcast = inbox.messages.find(
-        (m) => m.broadcast && m.subject === "Sprint Planning Meeting"
-      );
-      expect(broadcast).toBeDefined();
-      expect(broadcast?.from_agent).toBe(agents.coordinator);
-    });
-
-    it("step 3: frontend receives broadcast", async () => {
-      const inbox = await client.getInbox(agents.frontend, false);
-
-      const broadcast = inbox.messages.find(
-        (m) => m.broadcast && m.subject === "Sprint Planning Meeting"
-      );
-      expect(broadcast).toBeDefined();
-      expect(broadcast?.from_agent).toBe(agents.coordinator);
-    });
-
-    it("step 4: broadcast is tracked correctly", async () => {
-      // Note: In this implementation, broadcasters may receive their own broadcasts
-      // This test verifies the broadcast was delivered to multiple agents
-      const backendInbox = await client.getInbox(agents.backend, false);
-      const frontendInbox = await client.getInbox(agents.frontend, false);
-
-      const backendBroadcast = backendInbox.messages.find((m) => m.id === broadcastId);
-      const frontendBroadcast = frontendInbox.messages.find((m) => m.id === broadcastId);
-
-      expect(backendBroadcast).toBeDefined();
-      expect(frontendBroadcast).toBeDefined();
-      expect(backendBroadcast?.broadcast).toBe(true);
-      expect(frontendBroadcast?.broadcast).toBe(true);
-    });
-  });
-
-  describe("Scenario: Agent Status Tracking", () => {
-    it("all agents should be visible in agent list", async () => {
-      const result = await client.listAgents();
-
-      const registeredAgents = result.agents.filter((a) =>
-        Object.values(agents).includes(a.id)
-      );
-      expect(registeredAgents.length).toBe(3);
-    });
-
-    it("backend should show as busy after starting work", async () => {
-      const agent = await client.getAgent(agents.backend);
-
-      expect(agent.status).toBe("busy");
-      expect(agent.current_task).toContain("Implementing");
-    });
-
-    it("frontend should show as online (not busy)", async () => {
-      const agent = await client.getAgent(agents.frontend);
-
-      expect(agent.status).toBe("online");
-    });
-
-    it("agents can update their status", async () => {
-      await client.heartbeat(agents.frontend, "busy");
-      const agent = await client.getAgent(agents.frontend);
-
-      expect(agent.status).toBe("busy");
-    });
-  });
-
-  describe("Scenario: Multi-Agent Q&A", () => {
-    let questionId: string;
-    let backendAnswerId: string;
-    let frontendAnswerId: string;
-
-    it("step 1: coordinator asks question to backend", async () => {
-      const result = await client.sendMessage({
-        from_agent: agents.coordinator,
-        to_agent: agents.backend,
-        type: "question",
-        subject: "API Rate Limiting",
-        body: "What's the current rate limit configuration?",
-      });
-
-      questionId = result.message_id;
-      expect(questionId).toBeDefined();
-    });
-
-    it("step 2: backend answers the question", async () => {
-      const result = await client.reply(
-        questionId,
-        agents.backend,
-        "Rate limit is set to 100 requests/minute per API key."
-      );
-
-      backendAnswerId = result.message_id;
-      expect(backendAnswerId).toBeDefined();
-    });
-
-    it("step 3: coordinator asks frontend a different question", async () => {
-      const result = await client.sendMessage({
-        from_agent: agents.coordinator,
-        to_agent: agents.frontend,
-        type: "question",
-        subject: "UI Framework",
-        body: "Which UI framework are we using for the dashboard?",
-      });
-
-      const frontendQuestionId = result.message_id;
-
-      // Frontend answers
-      const answerResult = await client.reply(
-        frontendQuestionId,
-        agents.frontend,
-        "We're using React with TailwindCSS for the dashboard."
-      );
-
-      frontendAnswerId = answerResult.message_id;
-      expect(frontendAnswerId).toBeDefined();
-    });
-
-    it("step 4: coordinator has received all answers", async () => {
-      const inbox = await client.getInbox(agents.coordinator, false);
-
-      const backendAnswer = inbox.messages.find((m) => m.id === backendAnswerId);
-      const frontendAnswer = inbox.messages.find((m) => m.id === frontendAnswerId);
-
-      expect(backendAnswer).toBeDefined();
-      expect(frontendAnswer).toBeDefined();
-      expect(backendAnswer?.type).toBe("response");
-      expect(frontendAnswer?.type).toBe("response");
-    });
-  });
-
-  describe("Scenario: Urgent Priority Handling", () => {
-    it("should handle urgent priority messages", async () => {
-      const result = await client.sendMessage({
-        from_agent: agents.coordinator,
-        to_agent: agents.backend,
-        type: "task",
-        subject: "CRITICAL: Production Bug",
-        body: "There's a critical bug in production. Please investigate immediately.",
-        priority: "urgent",
-      });
-
-      expect(result.message_id).toBeDefined();
-
-      // Verify the message has urgent priority
-      const inbox = await client.getInbox(agents.backend, false);
-      const urgentMessage = inbox.messages.find(
-        (m) => m.subject === "CRITICAL: Production Bug"
-      );
-
-      expect(urgentMessage).toBeDefined();
-      expect(urgentMessage?.priority).toBe("urgent");
-    });
-  });
-});
+/**
+ * End-to-end multi-agent communication tests
+ *
+ * These tests simulate real-world multi-agent scenarios:
+ * - Multiple agents registering and communicating
+ * - Channel-based group communication
+ * - Message status tracking
+ * - Agent coordination workflows
+ *
+ * Requires the AgentHub server to be running on localhost:8787
+ * Set AGENTHUB_INTEGRATION_TESTS=1 to run these tests
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { ApiClient } from "./client.js";
+
+const TEST_URL = process.env.AGENTHUB_URL || "http://localhost:8787";
+const TEST_API_KEY = process.env.AGENTHUB_API_KEY || "test-key-123";
+const RUN_INTEGRATION = process.env.AGENTHUB_INTEGRATION_TESTS === "1";
+
+describe.skipIf(!RUN_INTEGRATION)("E2E: Multi-Agent Communication", () => {
+  let client: ApiClient;
+  const timestamp = Date.now();
+
+  // Create 3 agents for testing
+  const agents = {
+    coordinator: `coordinator-${timestamp}`,
+    backend: `backend-${timestamp}`,
+    frontend: `frontend-${timestamp}`,
+  };
+
+  beforeAll(async () => {
+    client = new ApiClient(TEST_URL, TEST_API_KEY);
+
+    // Register all agents
+    await client.registerAgent(agents.coordinator, "Coordinator Agent");
+    await client.registerAgent(agents.backend, "Backend Developer");
+    await client.registerAgent(agents.frontend, "Frontend Developer");
+  });
+
+  afterAll(async () => {
+    // Cleanup - disconnect all agents
+    for (const agentId of Object.values(agents)) {
+      try {
+        await client.disconnect(agentId);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  });
+
+  describe("Scenario: Task Assignment Flow", () => {
+    let taskMessageId: string;
+    let responseMessageId: string;
+
+    it("step 1: coordinator assigns task to backend", async () => {
+      const result = await client.sendMessage({
+        from_agent: agents.coordinator,
+        to_agent: agents.backend,
+        type: "task",
+        subject: "Implement API endpoint",
+        body: "Please implement the /users endpoint with CRUD operations",
+        priority: "high",
+      });
+
+      expect(result.message_id).toBeDefined();
+      expect(result.status).toBe("pending");
+      taskMessageId = result.message_id;
+    });
+
+    it("step 2: backend receives task in inbox", async () => {
+      const inbox = await client.getInbox(agents.backend, false);
+
+      expect(inbox.total).toBeGreaterThan(0);
+      const taskMessage = inbox.messages.find((m) => m.id === taskMessageId);
+      expect(taskMessage).toBeDefined();
+      expect(taskMessage?.from_agent).toBe(agents.coordinator);
+      expect(taskMessage?.subject).toBe("Implement API endpoint");
+      expect(taskMessage?.type).toBe("task");
+      expect(taskMessage?.priority).toBe("high");
+    });
+
+    it("step 3: backend marks task as read", async () => {
+      // First deliver
+      await fetch(`${TEST_URL}/messages/${taskMessageId}/status`, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": TEST_API_KEY,
+        },
+        body: JSON.stringify({ status: "delivered" }),
+      });
+
+      const result = await client.markRead(taskMessageId);
+      expect(result.updated).toBe(true);
+    });
+
+    it("step 4: backend starts work on the task", async () => {
+      const result = await client.startWork(
+        agents.backend,
+        "Implementing /users endpoint",
+        "API Development"
+      );
+
+      expect(result.acknowledged).toBe(true);
+    });
+
+    it("step 5: backend sends completion response", async () => {
+      const result = await client.reply(
+        taskMessageId,
+        agents.backend,
+        "Task completed. The /users endpoint is now live with full CRUD support."
+      );
+
+      expect(result.message_id).toBeDefined();
+      responseMessageId = result.message_id;
+    });
+
+    it("step 6: coordinator receives completion in inbox", async () => {
+      const inbox = await client.getInbox(agents.coordinator, false);
+
+      const responseMessage = inbox.messages.find((m) => m.id === responseMessageId);
+      expect(responseMessage).toBeDefined();
+      expect(responseMessage?.from_agent).toBe(agents.backend);
+      expect(responseMessage?.type).toBe("response");
+      expect(responseMessage?.reply_to).toBe(taskMessageId);
+    });
+  });
+
+  describe("Scenario: Broadcast Announcements", () => {
+    let broadcastId: string;
+
+    it("step 1: coordinator broadcasts announcement", async () => {
+      const result = await client.sendMessage({
+        from_agent: agents.coordinator,
+        broadcast: true,
+        type: "status",
+        subject: "Sprint Planning Meeting",
+        body: "Sprint planning in 30 minutes. Please prepare your updates.",
+      });
+
+      expect(result.message_id).toBeDefined();
+      broadcastId = result.message_id;
+    });
+
+    it("step 2: backend receives broadcast", async () => {
+      const inbox = await client.getInbox(agents.backend, false);
+
+      const broadcast = inbox.messages.find(
+        (m) => m.broadcast && m.subject === "Sprint Planning Meeting"
+      );
+      expect(broadcast).toBeDefined();
+      expect(broadcast?.from_agent).toBe(agents.coordinator);
+    });
+
+    it("step 3: frontend receives broadcast", async () => {
+      const inbox = await client.getInbox(agents.frontend, false);
+
+      const broadcast = inbox.messages.find(
+        (m) => m.broadcast && m.subject === "Sprint Planning Meeting"
+      );
+      expect(broadcast).toBeDefined();
+      expect(broadcast?.from_agent).toBe(agents.coordinator);
+    });
+
+    it("step 4: broadcast is tracked correctly", async () => {
+      // Note: In this implementation, broadcasters may receive their own broadcasts
+      // This test verifies the broadcast was delivered to multiple agents
+      const backendInbox = await client.getInbox(agents.backend, false);
+      const frontendInbox = await client.getInbox(agents.frontend, false);
+
+      const backendBroadcast = backendInbox.messages.find((m) => m.id === broadcastId);
+      const frontendBroadcast = frontendInbox.messages.find((m) => m.id === broadcastId);
+
+      expect(backendBroadcast).toBeDefined();
+      expect(frontendBroadcast).toBeDefined();
+      expect(backendBroadcast?.broadcast).toBe(true);
+      expect(frontendBroadcast?.broadcast).toBe(true);
+    });
+  });
+
+  describe("Scenario: Agent Status Tracking", () => {
+    it("all agents should be visible in agent list", async () => {
+      const result = await client.listAgents();
+
+      const registeredAgents = result.agents.filter((a) =>
+        Object.values(agents).includes(a.id)
+      );
+      expect(registeredAgents.length).toBe(3);
+    });
+
+    it("backend should show as busy after starting work", async () => {
+      const agent = await client.getAgent(agents.backend);
+
+      expect(agent.status).toBe("busy");
+      expect(agent.current_task).toContain("Implementing");
+    });
+
+    it("frontend should show as online (not busy)", async () => {
+      const agent = await client.getAgent(agents.frontend);
+
+      expect(agent.status).toBe("online");
+    });
+
+    it("agents can update their status", async () => {
+      await client.heartbeat(agents.frontend, "busy");
+      const agent = await client.getAgent(agents.frontend);
+
+      expect(agent.status).toBe("busy");
+    });
+  });
+
+  describe("Scenario: Multi-Agent Q&A", () => {
+    let questionId: string;
+    let backendAnswerId: string;
+    let frontendAnswerId: string;
+
+    it("step 1: coordinator asks question to backend", async () => {
+      const result = await client.sendMessage({
+        from_agent: agents.coordinator,
+        to_agent: agents.backend,
+        type: "question",
+        subject: "API Rate Limiting",
+        body: "What's the current rate limit configuration?",
+      });
+
+      questionId = result.message_id;
+      expect(questionId).toBeDefined();
+    });
+
+    it("step 2: backend answers the question", async () => {
+      const result = await client.reply(
+        questionId,
+        agents.backend,
+        "Rate limit is set to 100 requests/minute per API key."
+      );
+
+      backendAnswerId = result.message_id;
+      expect(backendAnswerId).toBeDefined();
+    });
+
+    it("step 3: coordinator asks frontend a different question", async () => {
+      const result = await client.sendMessage({
+        from_agent: agents.coordinator,
+        to_agent: agents.frontend,
+        type: "question",
+        subject: "UI Framework",
+        body: "Which UI framework are we using for the dashboard?",
+      });
+
+      const frontendQuestionId = result.message_id;
+
+      // Frontend answers
+      const answerResult = await client.reply(
+        frontendQuestionId,
+        agents.frontend,
+        "We're using React with TailwindCSS for the dashboard."
+      );
+
+      frontendAnswerId = answerResult.message_id;
+      expect(frontendAnswerId).toBeDefined();
+    });
+
+    it("step 4: coordinator has received all answers", async () => {
+      const inbox = await client.getInbox(agents.coordinator, false);
+
+      const backendAnswer = inbox.messages.find((m) => m.id === backendAnswerId);
+      const frontendAnswer = inbox.messages.find((m) => m.id === frontendAnswerId);
+
+      expect(backendAnswer).toBeDefined();
+      expect(frontendAnswer).toBeDefined();
+      expect(backendAnswer?.type).toBe("response");
+      expect(frontendAnswer?.type).toBe("response");
+    });
+  });
+
+  describe("Scenario: Urgent Priority Handling", () => {
+    it("should handle urgent priority messages", async () => {
+      const result = await client.sendMessage({
+        from_agent: agents.coordinator,
+        to_agent: agents.backend,
+        type: "task",
+        subject: "CRITICAL: Production Bug",
+        body: "There's a critical bug in production. Please investigate immediately.",
+        priority: "urgent",
+      });
+
+      expect(result.message_id).toBeDefined();
+
+      // Verify the message has urgent priority
+      const inbox = await client.getInbox(agents.backend, false);
+      const urgentMessage = inbox.messages.find(
+        (m) => m.subject === "CRITICAL: Production Bug"
+      );
+
+      expect(urgentMessage).toBeDefined();
+      expect(urgentMessage?.priority).toBe("urgent");
+    });
+  });
+});