agenthub-multiagent-mcp 1.1.2 → 1.1.4

package/src/tools/tools.test.ts

@@ -1,517 +1,522 @@
-/**
- * Unit tests for MCP tool handlers
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { registerTools, handleToolCall, ToolContext } from "./index.js";
-import { ApiClient } from "../client.js";
-
-// Mock the state module
-vi.mock("../state.js", () => ({
-  loadState: vi.fn(() => null),
-  saveState: vi.fn(),
-  deleteState: vi.fn(),
-  stateExists: vi.fn(() => false),
-  getCurrentOwner: vi.fn(() => "test-user"),
-}));
-
-// Mock the ApiClient
-const mockClient = {
-  registerAgent: vi.fn(),
-  reconnectAgent: vi.fn(),
-  startWork: vi.fn(),
-  heartbeat: vi.fn(),
-  disconnect: vi.fn(),
-  getAgent: vi.fn(),
-  listAgents: vi.fn(),
-  sendMessage: vi.fn(),
-  getInbox: vi.fn(),
-  markRead: vi.fn(),
-  reply: vi.fn(),
-  listChannels: vi.fn(),
-  joinChannel: vi.fn(),
-  leaveChannel: vi.fn(),
-} as unknown as ApiClient;
-
-// Mock context
-function createMockContext(): ToolContext {
-  let currentAgentId = "";
-  return {
-    getCurrentAgentId: () => currentAgentId,
-    setCurrentAgentId: (id: string) => {
-      currentAgentId = id;
-    },
-    stopHeartbeat: vi.fn(),
-    getWorkingDir: () => "/tmp/test-workdir",
-  };
-}
-
-describe("registerTools", () => {
-  it("should return all 19 tools", () => {
-    const tools = registerTools();
-    expect(tools).toHaveLength(19);
-  });
-
-  it("should have required tool names", () => {
-    const tools = registerTools();
-    const names = tools.map((t) => t.name);
-
-    expect(names).toContain("agent_register");
-    expect(names).toContain("agent_start_work");
-    expect(names).toContain("agent_set_status");
-    expect(names).toContain("agent_disconnect");
-    expect(names).toContain("send_message");
-    expect(names).toContain("send_to_channel");
-    expect(names).toContain("broadcast");
-    expect(names).toContain("check_inbox");
-    expect(names).toContain("mark_read");
-    expect(names).toContain("reply");
-    expect(names).toContain("list_agents");
-    expect(names).toContain("get_agent");
-    expect(names).toContain("list_channels");
-    expect(names).toContain("join_channel");
-    expect(names).toContain("leave_channel");
-  });
-
-  it("should have valid input schemas", () => {
-    const tools = registerTools();
-    for (const tool of tools) {
-      expect(tool.inputSchema).toBeDefined();
-      expect(tool.inputSchema.type).toBe("object");
-      expect(tool.inputSchema.properties).toBeDefined();
-    }
-  });
-});
-
-describe("handleToolCall", () => {
-  let context: ToolContext;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    context = createMockContext();
-    // Default mock for inbox (used by message wrapping)
-    vi.mocked(mockClient.getInbox).mockResolvedValue({ messages: [], total: 0 });
-  });
-
-  describe("agent_register", () => {
-    it("should register agent and set current agent ID", async () => {
-      const mockResult = {
-        agent_id: "test-agent",
-        token: "test-token-uuid",
-        model: "claude-opus-4.5",
-        model_provider: "anthropic",
-        registered_at: "2024-01-01T00:00:00Z",
-        slack_notified: false,
-        pending_tasks_count: 0,
-        unread_messages_count: 0,
-      };
-      vi.mocked(mockClient.registerAgent).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "agent_register",
-        { id: "test-agent", name: "Test Agent", model: "claude-opus-4.5" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.registerAgent).toHaveBeenCalledWith(
-        "test-agent",
-        "Test Agent",
-        "test-user",
-        "/tmp/test-workdir",
-        "claude-opus-4.5"
-      );
-      expect(context.getCurrentAgentId()).toBe("test-agent");
-      // Result is extended with mode and message
-      expect(result).toMatchObject({
-        ...mockResult,
-        mode: "registered",
-      });
-    });
-  });
-
-  describe("agent_start_work", () => {
-    it("should throw if not registered", async () => {
-      await expect(
-        handleToolCall(
-          "agent_start_work",
-          { task: "Building something" },
-          mockClient,
-          context
-        )
-      ).rejects.toThrow("Not registered");
-    });
-
-    it("should start work when registered", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = { acknowledged: true, slack_posted: true };
-      vi.mocked(mockClient.startWork).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "agent_start_work",
-        { task: "Building feature X", project: "TestProject" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.startWork).toHaveBeenCalledWith(
-        "test-agent",
-        "Building feature X",
-        "TestProject"
-      );
-      // Result is wrapped with messages
-      expect(result).toMatchObject({ result: mockResult });
-    });
-  });
-
-  describe("agent_set_status", () => {
-    it("should throw if not registered", async () => {
-      await expect(
-        handleToolCall(
-          "agent_set_status",
-          { status: "busy" },
-          mockClient,
-          context
-        )
-      ).rejects.toThrow("Not registered");
-    });
-
-    it("should update status when registered", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = { acknowledged: true, timestamp: "2024-01-01T00:00:00Z" };
-      vi.mocked(mockClient.heartbeat).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "agent_set_status",
-        { status: "busy" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.heartbeat).toHaveBeenCalledWith("test-agent", "busy");
-      // Result is wrapped with messages
-      expect(result).toMatchObject({ result: mockResult });
-    });
-  });
-
-  describe("agent_disconnect", () => {
-    it("should throw if not registered", async () => {
-      await expect(
-        handleToolCall("agent_disconnect", {}, mockClient, context)
-      ).rejects.toThrow("Not registered");
-    });
-
-    it("should disconnect and stop heartbeat when registered", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = { unregistered: true };
-      vi.mocked(mockClient.disconnect).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "agent_disconnect",
-        {},
-        mockClient,
-        context
-      );
-
-      expect(context.stopHeartbeat).toHaveBeenCalled();
-      expect(mockClient.disconnect).toHaveBeenCalledWith("test-agent");
-      expect(result).toEqual(mockResult);
-    });
-  });
-
-  describe("send_message", () => {
-    it("should throw if not registered", async () => {
-      await expect(
-        handleToolCall(
-          "send_message",
-          { to: "other-agent", type: "task", subject: "Test", body: "Content" },
-          mockClient,
-          context
-        )
-      ).rejects.toThrow("Not registered");
-    });
-
-    it("should send message when registered", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = {
-        message_id: "msg-1",
-        status: "pending",
-        created_at: "2024-01-01T00:00:00Z",
-      };
-      vi.mocked(mockClient.sendMessage).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "send_message",
-        {
-          to: "other-agent",
-          type: "task",
-          subject: "Test Task",
-          body: "Please do this",
-          priority: "high",
-        },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.sendMessage).toHaveBeenCalledWith({
-        from_agent: "test-agent",
-        to_agent: "other-agent",
-        type: "task",
-        subject: "Test Task",
-        body: "Please do this",
-        priority: "high",
-      });
-      // Result is wrapped with messages
-      expect(result).toMatchObject({ result: mockResult });
-    });
-  });
-
-  describe("send_to_channel", () => {
-    it("should send message to channel", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = {
-        message_id: "msg-1",
-        status: "pending",
-        created_at: "2024-01-01T00:00:00Z",
-      };
-      vi.mocked(mockClient.sendMessage).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "send_to_channel",
-        {
-          channel: "team-channel",
-          type: "status",
-          subject: "Update",
-          body: "Everything is good",
-        },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.sendMessage).toHaveBeenCalledWith({
-        from_agent: "test-agent",
-        to_channel: "team-channel",
-        type: "status",
-        subject: "Update",
-        body: "Everything is good",
-      });
-      // Result is wrapped with messages
-      expect(result).toMatchObject({ result: mockResult });
-    });
-  });
-
-  describe("broadcast", () => {
-    it("should send broadcast message", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = {
-        message_id: "msg-1",
-        status: "pending",
-        created_at: "2024-01-01T00:00:00Z",
-      };
-      vi.mocked(mockClient.sendMessage).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "broadcast",
-        {
-          type: "status",
-          subject: "System Alert",
-          body: "All systems operational",
-        },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.sendMessage).toHaveBeenCalledWith({
-        from_agent: "test-agent",
-        broadcast: true,
-        type: "status",
-        subject: "System Alert",
-        body: "All systems operational",
-      });
-      // Result is wrapped with messages
-      expect(result).toMatchObject({ result: mockResult });
-    });
-  });
-
-  describe("check_inbox", () => {
-    it("should get inbox messages", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = { messages: [], total: 0 };
-      vi.mocked(mockClient.getInbox).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "check_inbox",
-        { unread_only: true },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.getInbox).toHaveBeenCalledWith("test-agent", true);
-      expect(result).toEqual(mockResult);
-    });
-  });
-
-  describe("mark_read", () => {
-    it("should mark message as read", async () => {
-      // When not registered, result is NOT wrapped
-      const mockResult = { updated: true };
-      vi.mocked(mockClient.markRead).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "mark_read",
-        { message_id: "msg-1" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.markRead).toHaveBeenCalledWith("msg-1");
-      expect(result).toEqual(mockResult);
-    });
-  });
-
-  describe("list_agents", () => {
-    it("should list agents without filter", async () => {
-      // When not registered, result is NOT wrapped
-      const mockResult = { agents: [], total: 0 };
-      vi.mocked(mockClient.listAgents).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall("list_agents", {}, mockClient, context);
-
-      expect(mockClient.listAgents).toHaveBeenCalledWith(undefined);
-      expect(result).toEqual(mockResult);
-    });
-
-    it("should list agents with status filter", async () => {
-      // When not registered, result is NOT wrapped
-      const mockResult = {
-        agents: [
-          {
-            id: "agent-1",
-            name: "Agent 1",
-            owner: "test-user",
-            model: "claude-opus-4.5",
-            model_provider: "anthropic",
-            status: "online" as const,
-            working_dir: "",
-            current_task: "",
-            channels: [],
-            registered_at: "",
-            last_heartbeat: "",
-          },
-        ],
-        total: 1,
-      };
-      vi.mocked(mockClient.listAgents).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "list_agents",
-        { status: "online" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.listAgents).toHaveBeenCalledWith("online");
-      expect(result).toEqual(mockResult);
-    });
-  });
-
-  describe("get_agent", () => {
-    it("should get agent details", async () => {
-      // When not registered, result is NOT wrapped
-      const mockAgent = {
-        id: "agent-1",
-        name: "Agent 1",
-        owner: "test-user",
-        model: "claude-opus-4.5",
-        model_provider: "anthropic",
-        status: "online" as const,
-        working_dir: "/path",
-        current_task: "Task",
-        channels: [],
-        registered_at: "",
-        last_heartbeat: "",
-      };
-      vi.mocked(mockClient.getAgent).mockResolvedValue(mockAgent);
-
-      const result = await handleToolCall(
-        "get_agent",
-        { id: "agent-1" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.getAgent).toHaveBeenCalledWith("agent-1");
-      expect(result).toEqual(mockAgent);
-    });
-  });
-
-  describe("list_channels", () => {
-    it("should list channels", async () => {
-      // When not registered, result is NOT wrapped
-      const mockResult = { channels: [], total: 0 };
-      vi.mocked(mockClient.listChannels).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "list_channels",
-        {},
-        mockClient,
-        context
-      );
-
-      expect(mockClient.listChannels).toHaveBeenCalled();
-      expect(result).toEqual(mockResult);
-    });
-  });
-
-  describe("join_channel", () => {
-    it("should join channel", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = { subscribed: true };
-      vi.mocked(mockClient.joinChannel).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "join_channel",
-        { channel: "team-channel" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.joinChannel).toHaveBeenCalledWith(
-        "team-channel",
-        "test-agent"
-      );
-      // Result is wrapped with messages
-      expect(result).toMatchObject({ result: mockResult });
-    });
-  });
-
-  describe("leave_channel", () => {
-    it("should leave channel", async () => {
-      context.setCurrentAgentId("test-agent");
-      const mockResult = { unsubscribed: true };
-      vi.mocked(mockClient.leaveChannel).mockResolvedValue(mockResult);
-
-      const result = await handleToolCall(
-        "leave_channel",
-        { channel: "team-channel" },
-        mockClient,
-        context
-      );
-
-      expect(mockClient.leaveChannel).toHaveBeenCalledWith(
-        "team-channel",
-        "test-agent"
-      );
-      // Result is wrapped with messages
-      expect(result).toMatchObject({ result: mockResult });
-    });
-  });
-
-  describe("unknown tool", () => {
-    it("should throw for unknown tool", async () => {
-      await expect(
-        handleToolCall("unknown_tool", {}, mockClient, context)
-      ).rejects.toThrow("Unknown tool: unknown_tool");
-    });
-  });
-});
+/**
+ * Unit tests for MCP tool handlers
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { registerTools, handleToolCall, ToolContext } from "./index.js";
+import { ApiClient } from "../client.js";
+
+// Mock the state module
+vi.mock("../state.js", () => ({
+  loadState: vi.fn(() => null),
+  saveState: vi.fn(),
+  deleteState: vi.fn(),
+  stateExists: vi.fn(() => false),
+  getCurrentOwner: vi.fn(() => "test-user"),
+}));
+
+// Mock the ApiClient
+const mockClient = {
+  registerAgent: vi.fn(),
+  reconnectAgent: vi.fn(),
+  startWork: vi.fn(),
+  heartbeat: vi.fn(),
+  disconnect: vi.fn(),
+  getAgent: vi.fn(),
+  listAgents: vi.fn(),
+  sendMessage: vi.fn(),
+  getInbox: vi.fn(),
+  markRead: vi.fn(),
+  reply: vi.fn(),
+  listChannels: vi.fn(),
+  joinChannel: vi.fn(),
+  leaveChannel: vi.fn(),
+} as unknown as ApiClient;
+
+// Mock context
+function createMockContext(): ToolContext {
+  let currentAgentId = "";
+  return {
+    getCurrentAgentId: () => currentAgentId,
+    setCurrentAgentId: (id: string) => {
+      currentAgentId = id;
+    },
+    stopHeartbeat: vi.fn(),
+    getWorkingDir: () => "/tmp/test-workdir",
+  };
+}
+
+describe("registerTools", () => {
+  it("should return all 19 tools", () => {
+    const tools = registerTools();
+    expect(tools).toHaveLength(19);
+  });
+
+  it("should have required tool names", () => {
+    const tools = registerTools();
+    const names = tools.map((t) => t.name);
+
+    expect(names).toContain("agent_register");
+    expect(names).toContain("agent_start_work");
+    expect(names).toContain("agent_set_status");
+    expect(names).toContain("agent_disconnect");
+    expect(names).toContain("send_message");
+    expect(names).toContain("send_to_channel");
+    expect(names).toContain("broadcast");
+    expect(names).toContain("check_inbox");
+    expect(names).toContain("mark_read");
+    expect(names).toContain("reply");
+    expect(names).toContain("list_agents");
+    expect(names).toContain("get_agent");
+    expect(names).toContain("list_channels");
+    expect(names).toContain("join_channel");
+    expect(names).toContain("leave_channel");
+  });
+
+  it("should have valid input schemas", () => {
+    const tools = registerTools();
+    for (const tool of tools) {
+      expect(tool.inputSchema).toBeDefined();
+      expect(tool.inputSchema.type).toBe("object");
+      expect(tool.inputSchema.properties).toBeDefined();
+    }
+  });
+});
+
+describe("handleToolCall", () => {
+  let context: ToolContext;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    context = createMockContext();
+    // Default mock for inbox (used by message wrapping)
+    vi.mocked(mockClient.getInbox).mockResolvedValue({ messages: [], total: 0 });
+  });
+
+  describe("agent_register", () => {
+    it("should register agent and set current agent ID", async () => {
+      const mockResult = {
+        agent_id: "test-agent",
+        token: "test-token-uuid",
+        model: "claude-opus-4.5",
+        model_provider: "anthropic",
+        registered_at: "2024-01-01T00:00:00Z",
+        slack_notified: false,
+        pending_tasks_count: 0,
+        unread_messages_count: 0,
+      };
+      vi.mocked(mockClient.registerAgent).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "agent_register",
+        { id: "test-agent", name: "Test Agent", model: "claude-opus-4.5" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.registerAgent).toHaveBeenCalledWith(
+        "test-agent",
+        "Test Agent",
+        "test-user",
+        "/tmp/test-workdir",
+        "claude-opus-4.5"
+      );
+      expect(context.getCurrentAgentId()).toBe("test-agent");
+      // Result is extended with mode and message
+      expect(result).toMatchObject({
+        ...mockResult,
+        mode: "registered",
+      });
+    });
+  });
+
+  describe("agent_start_work", () => {
+    it("should throw if not registered", async () => {
+      await expect(
+        handleToolCall(
+          "agent_start_work",
+          { task: "Building something" },
+          mockClient,
+          context
+        )
+      ).rejects.toThrow("Not registered");
+    });
+
+    it("should start work when registered", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = { acknowledged: true, slack_posted: true };
+      vi.mocked(mockClient.startWork).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "agent_start_work",
+        { task: "Building feature X", project: "TestProject" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.startWork).toHaveBeenCalledWith(
+        "test-agent",
+        "Building feature X",
+        "TestProject"
+      );
+      // Result is wrapped with messages
+      expect(result).toMatchObject({ result: mockResult });
+    });
+  });
+
+  describe("agent_set_status", () => {
+    it("should throw if not registered", async () => {
+      await expect(
+        handleToolCall(
+          "agent_set_status",
+          { status: "busy" },
+          mockClient,
+          context
+        )
+      ).rejects.toThrow("Not registered");
+    });
+
+    it("should update status when registered", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = {
+        acknowledged: true,
+        timestamp: "2024-01-01T00:00:00Z",
+        pending_tasks_count: 0,
+        unread_messages_count: 0,
+      };
+      vi.mocked(mockClient.heartbeat).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "agent_set_status",
+        { status: "busy" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.heartbeat).toHaveBeenCalledWith("test-agent", "busy");
+      // Result is wrapped with messages
+      expect(result).toMatchObject({ result: mockResult });
+    });
+  });
+
+  describe("agent_disconnect", () => {
+    it("should throw if not registered", async () => {
+      await expect(
+        handleToolCall("agent_disconnect", {}, mockClient, context)
+      ).rejects.toThrow("Not registered");
+    });
+
+    it("should disconnect and stop heartbeat when registered", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = { unregistered: true };
+      vi.mocked(mockClient.disconnect).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "agent_disconnect",
+        {},
+        mockClient,
+        context
+      );
+
+      expect(context.stopHeartbeat).toHaveBeenCalled();
+      expect(mockClient.disconnect).toHaveBeenCalledWith("test-agent");
+      expect(result).toEqual(mockResult);
+    });
+  });
+
+  describe("send_message", () => {
+    it("should throw if not registered", async () => {
+      await expect(
+        handleToolCall(
+          "send_message",
+          { to: "other-agent", type: "task", subject: "Test", body: "Content" },
+          mockClient,
+          context
+        )
+      ).rejects.toThrow("Not registered");
+    });
+
+    it("should send message when registered", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = {
+        message_id: "msg-1",
+        status: "pending",
+        created_at: "2024-01-01T00:00:00Z",
+      };
+      vi.mocked(mockClient.sendMessage).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "send_message",
+        {
+          to: "other-agent",
+          type: "task",
+          subject: "Test Task",
+          body: "Please do this",
+          priority: "high",
+        },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.sendMessage).toHaveBeenCalledWith({
+        from_agent: "test-agent",
+        to_agent: "other-agent",
+        type: "task",
+        subject: "Test Task",
+        body: "Please do this",
+        priority: "high",
+      });
+      // Result is wrapped with messages
+      expect(result).toMatchObject({ result: mockResult });
+    });
+  });
+
+  describe("send_to_channel", () => {
+    it("should send message to channel", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = {
+        message_id: "msg-1",
+        status: "pending",
+        created_at: "2024-01-01T00:00:00Z",
+      };
+      vi.mocked(mockClient.sendMessage).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "send_to_channel",
+        {
+          channel: "team-channel",
+          type: "status",
+          subject: "Update",
+          body: "Everything is good",
+        },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.sendMessage).toHaveBeenCalledWith({
+        from_agent: "test-agent",
+        to_channel: "team-channel",
+        type: "status",
+        subject: "Update",
+        body: "Everything is good",
+      });
+      // Result is wrapped with messages
+      expect(result).toMatchObject({ result: mockResult });
+    });
+  });
+
+  describe("broadcast", () => {
+    it("should send broadcast message", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = {
+        message_id: "msg-1",
+        status: "pending",
+        created_at: "2024-01-01T00:00:00Z",
+      };
+      vi.mocked(mockClient.sendMessage).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "broadcast",
+        {
+          type: "status",
+          subject: "System Alert",
+          body: "All systems operational",
+        },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.sendMessage).toHaveBeenCalledWith({
+        from_agent: "test-agent",
+        broadcast: true,
+        type: "status",
+        subject: "System Alert",
+        body: "All systems operational",
+      });
+      // Result is wrapped with messages
+      expect(result).toMatchObject({ result: mockResult });
+    });
+  });
+
+  describe("check_inbox", () => {
+    it("should get inbox messages", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = { messages: [], total: 0 };
+      vi.mocked(mockClient.getInbox).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "check_inbox",
+        { unread_only: true },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.getInbox).toHaveBeenCalledWith("test-agent", true);
+      expect(result).toEqual(mockResult);
+    });
+  });
+
+  describe("mark_read", () => {
+    it("should mark message as read", async () => {
+      // When not registered, result is NOT wrapped
+      const mockResult = { updated: true };
+      vi.mocked(mockClient.markRead).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "mark_read",
+        { message_id: "msg-1" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.markRead).toHaveBeenCalledWith("msg-1");
+      expect(result).toEqual(mockResult);
+    });
+  });
+
+  describe("list_agents", () => {
+    it("should list agents without filter", async () => {
+      // When not registered, result is NOT wrapped
+      const mockResult = { agents: [], total: 0 };
+      vi.mocked(mockClient.listAgents).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall("list_agents", {}, mockClient, context);
+
+      expect(mockClient.listAgents).toHaveBeenCalledWith(undefined);
+      expect(result).toEqual(mockResult);
+    });
+
+    it("should list agents with status filter", async () => {
+      // When not registered, result is NOT wrapped
+      const mockResult = {
+        agents: [
+          {
+            id: "agent-1",
+            name: "Agent 1",
+            owner: "test-user",
+            model: "claude-opus-4.5",
+            model_provider: "anthropic",
+            status: "online" as const,
+            working_dir: "",
+            current_task: "",
+            channels: [],
+            registered_at: "",
+            last_heartbeat: "",
+          },
+        ],
+        total: 1,
+      };
+      vi.mocked(mockClient.listAgents).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "list_agents",
+        { status: "online" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.listAgents).toHaveBeenCalledWith("online");
+      expect(result).toEqual(mockResult);
+    });
+  });
+
+  describe("get_agent", () => {
+    it("should get agent details", async () => {
+      // When not registered, result is NOT wrapped
+      const mockAgent = {
+        id: "agent-1",
+        name: "Agent 1",
+        owner: "test-user",
+        model: "claude-opus-4.5",
+        model_provider: "anthropic",
+        status: "online" as const,
+        working_dir: "/path",
+        current_task: "Task",
+        channels: [],
+        registered_at: "",
+        last_heartbeat: "",
+      };
+      vi.mocked(mockClient.getAgent).mockResolvedValue(mockAgent);
+
+      const result = await handleToolCall(
+        "get_agent",
+        { id: "agent-1" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.getAgent).toHaveBeenCalledWith("agent-1");
+      expect(result).toEqual(mockAgent);
+    });
+  });
+
+  describe("list_channels", () => {
+    it("should list channels", async () => {
+      // When not registered, result is NOT wrapped
+      const mockResult = { channels: [], total: 0 };
+      vi.mocked(mockClient.listChannels).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "list_channels",
+        {},
+        mockClient,
+        context
+      );
+
+      expect(mockClient.listChannels).toHaveBeenCalled();
+      expect(result).toEqual(mockResult);
+    });
+  });
+
+  describe("join_channel", () => {
+    it("should join channel", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = { subscribed: true };
+      vi.mocked(mockClient.joinChannel).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "join_channel",
+        { channel: "team-channel" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.joinChannel).toHaveBeenCalledWith(
+        "team-channel",
+        "test-agent"
+      );
+      // Result is wrapped with messages
+      expect(result).toMatchObject({ result: mockResult });
+    });
+  });
+
+  describe("leave_channel", () => {
+    it("should leave channel", async () => {
+      context.setCurrentAgentId("test-agent");
+      const mockResult = { unsubscribed: true };
+      vi.mocked(mockClient.leaveChannel).mockResolvedValue(mockResult);
+
+      const result = await handleToolCall(
+        "leave_channel",
+        { channel: "team-channel" },
+        mockClient,
+        context
+      );
+
+      expect(mockClient.leaveChannel).toHaveBeenCalledWith(
+        "team-channel",
+        "test-agent"
+      );
+      // Result is wrapped with messages
+      expect(result).toMatchObject({ result: mockResult });
+    });
+  });
+
+  describe("unknown tool", () => {
+    it("should throw for unknown tool", async () => {
+      await expect(
+        handleToolCall("unknown_tool", {}, mockClient, context)
+      ).rejects.toThrow("Unknown tool: unknown_tool");
+    });
+  });
+});