@johpaz/hive-core 1.0.7 → 1.0.10

package/src/agents/inter-agent-bus.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect, beforeEach, vi } from "bun:test";
+import { InterAgentBus, type AgentMessage } from "./inter-agent-bus";
+import { eventBus } from "../events/event-bus";
+
+describe("InterAgentBus", () => {
+  let bus: InterAgentBus;
+
+  beforeEach(() => {
+    bus = new InterAgentBus();
+    eventBus.removeAllListeners();
+  });
+
+  describe("subscribe", () => {
+    it("should subscribe to topic", () => {
+      const handler = vi.fn();
+      bus.subscribe("agent-1", "task:request", handler);
+
+      const stats = bus.getStats();
+      expect(stats.subscriptionsByAgent["agent-1"]).toBe(1);
+      expect(stats.subscriptionsByTopic["task:request"]).toBe(1);
+    });
+
+    it("should return unsubscribe function", () => {
+      const handler = vi.fn();
+      const unsubscribe = bus.subscribe("agent-1", "task:request", handler);
+
+      unsubscribe();
+
+      const stats = bus.getStats();
+      expect(stats.totalSubscriptions).toBe(0);
+    });
+
+    it("should support once option", async () => {
+      const handler = vi.fn();
+      bus.subscribe("agent-1", "task:request", handler, { once: true });
+
+      await bus.send({
+        from: "agent-2",
+        to: "agent-1",
+        type: "request",
+        topic: "task:request",
+        payload: { data: "test" },
+        correlationId: "corr-1",
+      });
+
+      await bus.send({
+        from: "agent-2",
+        to: "agent-1",
+        type: "request",
+        topic: "task:request",
+        payload: { data: "test2" },
+        correlationId: "corr-2",
+      });
+
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+
+    it("should support priority ordering", () => {
+      const calls: string[] = [];
+      
+      bus.subscribe("agent-1", "topic", () => calls.push("second"));
+      bus.subscribe("agent-1", "topic", () => calls.push("first"), { priority: 0 });
+
+      const stats = bus.getStats();
+      expect(stats.subscriptionsByAgent["agent-1"]).toBe(2);
+    });
+  });
+
+  describe("unsubscribe", () => {
+    it("should remove handler", () => {
+      const handler = vi.fn();
+      bus.subscribe("agent-1", "topic", handler);
+      bus.unsubscribe("agent-1", "topic", handler);
+
+      const stats = bus.getStats();
+      expect(stats.totalSubscriptions).toBe(0);
+    });
+
+    it("should clean up empty topic", () => {
+      const handler = vi.fn();
+      bus.subscribe("agent-1", "topic", handler);
+      bus.unsubscribe("agent-1", "topic", handler);
+
+      const stats = bus.getStats();
+      expect(stats.subscriptionsByTopic["topic"]).toBeUndefined();
+    });
+
+    it("should clean up empty agent", () => {
+      const handler = vi.fn();
+      bus.subscribe("agent-1", "topic", handler);
+      bus.unsubscribe("agent-1", "topic", handler);
+
+      const stats = bus.getStats();
+      expect(stats.subscriptionsByAgent["agent-1"]).toBeUndefined();
+    });
+  });
+
+  describe("send", () => {
+    it("should deliver message to agent", async () => {
+      const handler = vi.fn();
+      bus.subscribe("agent-1", "task:request", handler);
+
+      await bus.send({
+        from: "agent-2",
+        to: "agent-1",
+        type: "request",
+        topic: "task:request",
+        payload: { data: "test" },
+        correlationId: "corr-1",
+      });
+
+      expect(handler).toHaveBeenCalled();
+      const message = handler.mock.calls[0][0] as AgentMessage;
+      expect(message.id).toBeDefined();
+      expect(message.timestamp).toBeDefined();
+      expect(message.payload).toEqual({ data: "test" });
+    });
+
+    it("should broadcast to all subscribers", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      bus.subscribe("agent-1", "broadcast:status", handler1);
+      bus.subscribe("agent-2", "broadcast:status", handler2);
+
+      await bus.send({
+        from: "system",
+        to: "broadcast",
+        type: "event",
+        topic: "broadcast:status",
+        payload: { status: "active" },
+        correlationId: "corr-1",
+      });
+
+      expect(handler1).toHaveBeenCalled();
+      expect(handler2).toHaveBeenCalled();
+    });
+
+    it("should handle missing handlers gracefully", async () => {
+      await bus.send({
+        from: "agent-2",
+        to: "agent-1",
+        type: "request",
+        topic: "unknown:topic",
+        payload: {},
+        correlationId: "corr-1",
+      });
+
+      expect(true).toBe(true);
+    });
+
+    it("should handle handler errors", async () => {
+      const errorHandler = vi.fn().mockRejectedValue(new Error("Handler error"));
+      bus.subscribe("agent-1", "topic", errorHandler);
+
+      await bus.send({
+        from: "agent-2",
+        to: "agent-1",
+        type: "request",
+        topic: "topic",
+        payload: {},
+        correlationId: "corr-1",
+      });
+
+      expect(errorHandler).toHaveBeenCalled();
+    });
+  });
+
+  describe("request/response", () => {
+    it("should make request and receive response", async () => {
+      bus.subscribe("agent-1", "task:execute", async (msg: AgentMessage) => {
+        await bus.respond(msg, { result: "done" });
+      });
+
+      const response = bus.request("agent-1", "task:execute", { task: "test" }, 1000);
+      
+      await expect(response).resolves.toEqual({ result: "done" });
+    });
+
+    it("should timeout if no response", async () => {
+      const response = bus.request("agent-1", "unknown:topic", {}, 100);
+      
+      await expect(response).rejects.toThrow("Request timeout");
+    });
+
+    it("should handle error responses", async () => {
+      bus.subscribe("agent-1", "task:execute", async (msg: AgentMessage) => {
+        const pending = (bus as unknown as { pendingRequests: Map<string, unknown> }).pendingRequests.get(msg.correlationId);
+        if (pending) {
+          (pending as { reject: (err: Error) => void }).reject(new Error("Something went wrong"));
+        }
+      });
+
+      const response = bus.request("agent-1", "task:execute", {}, 1000);
+      
+      await expect(response).rejects.toThrow("Something went wrong");
+    });
+  });
+
+  describe("getStats", () => {
+    it("should return correct stats", async () => {
+      bus.subscribe("agent-1", "topic1", vi.fn());
+      bus.subscribe("agent-1", "topic2", vi.fn());
+      bus.subscribe("agent-2", "topic1", vi.fn());
+
+      await bus.send({
+        from: "system",
+        to: "agent-1",
+        type: "event",
+        topic: "topic1",
+        payload: {},
+        correlationId: "corr-1",
+      });
+
+      const stats = bus.getStats();
+
+      expect(stats.totalSubscriptions).toBe(3);
+      expect(stats.subscriptionsByAgent["agent-1"]).toBe(2);
+      expect(stats.subscriptionsByAgent["agent-2"]).toBe(1);
+      expect(stats.messagesProcessed).toBe(1);
+    });
+
+    it("should track pending responses", () => {
+      const requestPromise = bus.request("agent-1", "topic", {}, 5000);
+
+      const stats = bus.getStats();
+      expect(stats.pendingResponses).toBe(1);
+    });
+  });
+
+  describe("clearAgent", () => {
+    it("should clear agent handlers", () => {
+      bus.subscribe("agent-1", "topic", vi.fn());
+      bus.clearAgent("agent-1");
+
+      const stats = bus.getStats();
+      expect(stats.subscriptionsByAgent["agent-1"]).toBeUndefined();
+    });
+
+    it("should reject pending requests for agent", async () => {
+      const requestPromise = bus.request("agent-1", "topic", {}, 5000);
+      
+      bus.clearAgent("agent-1");
+
+      await expect(requestPromise).rejects.toThrow("disconnected");
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear all state", async () => {
+      bus.subscribe("agent-1", "topic", vi.fn());
+      const requestPromise = bus.request("agent-2", "topic", {}, 5000);
+
+      bus.clear();
+
+      const stats = bus.getStats();
+      expect(stats.totalSubscriptions).toBe(0);
+      expect(stats.messagesProcessed).toBe(0);
+      expect(stats.pendingResponses).toBe(0);
+
+      await expect(requestPromise).rejects.toThrow("Bus cleared");
+    });
+  });
+});

package/src/agents/inter-agent-bus.ts

@@ -0,0 +1,279 @@
+import { logger } from "../utils/logger.ts";
+import { eventBus } from "../events/event-bus.ts";
+
+export interface AgentMessage {
+  id: string;
+  from: string;
+  to: string;
+  type: "request" | "response" | "event" | "error" | "ack";
+  topic: string;
+  payload: unknown;
+  correlationId: string;
+  timestamp: number;
+  ttl?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AgentMessageHandler {
+  (message: AgentMessage): Promise<unknown> | unknown;
+}
+
+export interface SubscriptionOptions {
+  once?: boolean;
+  priority?: number;
+}
+
+export interface BusStats {
+  totalSubscriptions: number;
+  subscriptionsByAgent: Record<string, number>;
+  subscriptionsByTopic: Record<string, number>;
+  messagesProcessed: number;
+  pendingResponses: number;
+}
+
+interface PendingRequest {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  timeoutId: ReturnType<typeof setTimeout>;
+}
+
+export class InterAgentBus {
+  private handlers: Map<string, Map<string, AgentMessageHandler[]>> = new Map();
+  private pendingRequests: Map<string, PendingRequest> = new Map();
+  private messagesProcessed = 0;
+  private log = logger.child("inter-agent-bus");
+
+  subscribe(
+    agentId: string,
+    topic: string,
+    handler: AgentMessageHandler,
+    options?: SubscriptionOptions
+  ): () => void {
+    if (!this.handlers.has(agentId)) {
+      this.handlers.set(agentId, new Map());
+    }
+
+    const agentHandlers = this.handlers.get(agentId)!;
+
+    if (options?.once) {
+      const wrappedHandler: AgentMessageHandler = async (msg) => {
+        this.unsubscribe(agentId, topic, wrappedHandler);
+        return handler(msg);
+      };
+      if (!agentHandlers.has(topic)) {
+        agentHandlers.set(topic, []);
+      }
+      agentHandlers.get(topic)!.push(wrappedHandler);
+      this.log.debug(`Subscribed (once): ${agentId} -> ${topic}`);
+      return () => this.unsubscribe(agentId, topic, wrappedHandler);
+    }
+
+    if (!agentHandlers.has(topic)) {
+      agentHandlers.set(topic, []);
+    }
+
+    const handlers = agentHandlers.get(topic)!;
+    if (options?.priority !== undefined) {
+      handlers.splice(options.priority, 0, handler);
+    } else {
+      handlers.push(handler);
+    }
+
+    this.log.debug(`Subscribed: ${agentId} -> ${topic}`);
+
+    return () => this.unsubscribe(agentId, topic, handler);
+  }
+
+  unsubscribe(agentId: string, topic: string, handler: AgentMessageHandler): void {
+    const agentHandlers = this.handlers.get(agentId);
+    if (!agentHandlers) return;
+
+    const topicHandlers = agentHandlers.get(topic);
+    if (!topicHandlers) return;
+
+    const index = topicHandlers.indexOf(handler);
+    if (index > -1) {
+      topicHandlers.splice(index, 1);
+      this.log.debug(`Unsubscribed: ${agentId} -> ${topic}`);
+    }
+
+    if (topicHandlers.length === 0) {
+      agentHandlers.delete(topic);
+    }
+
+    if (agentHandlers.size === 0) {
+      this.handlers.delete(agentId);
+    }
+  }
+
+  async send(message: Omit<AgentMessage, "id" | "timestamp">): Promise<void> {
+    const fullMessage: AgentMessage = {
+      ...message,
+      id: crypto.randomUUID(),
+      timestamp: Date.now(),
+    };
+
+    this.messagesProcessed++;
+
+    if (message.to === "broadcast") {
+      await this.broadcast(fullMessage);
+    } else {
+      await this.deliver(message.to, fullMessage);
+    }
+
+    eventBus.emit("tool:completed", {
+      toolName: `inter-agent:${message.topic}`,
+      result: { delivered: true },
+      duration: 0,
+      success: true,
+    });
+  }
+
+  async request(
+    to: string,
+    topic: string,
+    payload: unknown,
+    timeout = 30000
+  ): Promise<unknown> {
+    const correlationId = crypto.randomUUID();
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(correlationId);
+        reject(new Error(`Request timeout: ${topic} -> ${to}`));
+      }, timeout);
+
+      this.pendingRequests.set(correlationId, { resolve, reject, timeoutId });
+
+      this.send({
+        from: "bus",
+        to,
+        type: "request",
+        topic,
+        payload,
+        correlationId,
+      });
+    });
+  }
+
+  async respond(originalMessage: AgentMessage, response: unknown): Promise<void> {
+    await this.send({
+      from: originalMessage.to,
+      to: originalMessage.from,
+      type: "response",
+      topic: originalMessage.topic,
+      payload: response,
+      correlationId: originalMessage.correlationId,
+    });
+  }
+
+  handleResponse(message: AgentMessage): void {
+    const pending = this.pendingRequests.get(message.correlationId);
+    if (!pending) return;
+
+    clearTimeout(pending.timeoutId);
+    this.pendingRequests.delete(message.correlationId);
+
+    if (message.type === "error") {
+      pending.reject(new Error(String(message.payload)));
+    } else {
+      pending.resolve(message.payload);
+    }
+  }
+
+  async broadcast(message: AgentMessage): Promise<void> {
+    const deliveries: Promise<void>[] = [];
+
+    for (const [agentId, topics] of this.handlers) {
+      if (topics.has(message.topic)) {
+        deliveries.push(this.deliver(agentId, message));
+      }
+    }
+
+    await Promise.allSettled(deliveries);
+  }
+
+  private async deliver(agentId: string, message: AgentMessage): Promise<void> {
+    if (message.type === "response") {
+      this.handleResponse(message);
+      return;
+    }
+
+    const agentHandlers = this.handlers.get(agentId);
+    if (!agentHandlers) {
+      this.log.debug(`No handlers for agent: ${agentId}`);
+      return;
+    }
+
+    const topicHandlers = agentHandlers.get(message.topic);
+    if (!topicHandlers || topicHandlers.length === 0) {
+      this.log.debug(`No handlers for topic: ${message.topic} at ${agentId}`);
+      return;
+    }
+
+    for (const handler of topicHandlers) {
+      try {
+        await handler(message);
+      } catch (error) {
+        this.log.error(`Handler error for ${message.topic}`, {
+          agentId,
+          error: (error as Error).message,
+        });
+      }
+    }
+  }
+
+  getStats(): BusStats {
+    const subscriptionsByAgent: Record<string, number> = {};
+    const subscriptionsByTopic: Record<string, number> = {};
+
+    for (const [agentId, topics] of this.handlers) {
+      subscriptionsByAgent[agentId] = Array.from(topics.values()).reduce(
+        (sum, handlers) => sum + handlers.length,
+        0
+      );
+
+      for (const [topic, handlers] of topics) {
+        subscriptionsByTopic[topic] = (subscriptionsByTopic[topic] ?? 0) + handlers.length;
+      }
+    }
+
+    const totalSubscriptions = Object.values(subscriptionsByAgent).reduce(
+      (sum, n) => sum + n,
+      0
+    );
+
+    return {
+      totalSubscriptions,
+      subscriptionsByAgent,
+      subscriptionsByTopic,
+      messagesProcessed: this.messagesProcessed,
+      pendingResponses: this.pendingRequests.size,
+    };
+  }
+
+  clearAgent(agentId: string): void {
+    this.handlers.delete(agentId);
+
+    for (const [correlationId, pending] of this.pendingRequests) {
+      pending.reject(new Error(`Agent ${agentId} disconnected`));
+      this.pendingRequests.delete(correlationId);
+    }
+
+    this.log.info(`Cleared all handlers for agent: ${agentId}`);
+  }
+
+  clear(): void {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(new Error("Bus cleared"));
+    }
+
+    this.handlers.clear();
+    this.pendingRequests.clear();
+    this.messagesProcessed = 0;
+    this.log.info("Bus cleared");
+  }
+}
+
+export const interAgentBus = new InterAgentBus();