@johpaz/hive-core 1.0.8 → 1.0.10

package/src/agents/router.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect, beforeEach, vi } from "bun:test";
+import { TaskRouter, DefaultTaskExecutor, type TaskExecutor } from "./router";
+import { AgentRegistry, type AgentDefinition, type Task } from "./registry";
+import { InterAgentBus } from "./inter-agent-bus";
+import { eventBus } from "../events/event-bus";
+
+describe("TaskRouter", () => {
+  let registry: AgentRegistry;
+  let bus: InterAgentBus;
+  let router: TaskRouter;
+  let executor: TaskExecutor;
+
+  const createAgent = (id: string, capabilities: string[], maxTasks = 3): AgentDefinition => ({
+    id,
+    name: `Agent ${id}`,
+    description: `Test agent ${id}`,
+    capabilities,
+    modelConfig: { provider: "openai", model: "gpt-4" },
+    systemPrompt: "You are helpful",
+    maxConcurrentTasks: maxTasks,
+    currentLoad: 0,
+  });
+
+  const createTask = (id: string, capabilities: string[], requiresTeam = false): Task => ({
+    id,
+    description: `Task ${id}`,
+    requiredCapabilities: capabilities,
+    priority: "normal",
+    requiresTeam,
+  });
+
+  beforeEach(() => {
+    registry = new AgentRegistry();
+    bus = new InterAgentBus();
+    router = new TaskRouter(registry, bus);
+    executor = new DefaultTaskExecutor();
+    eventBus.removeAllListeners();
+  });
+
+  describe("route", () => {
+    it("should route task to best agent", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      registry.register(createAgent("agent-2", ["test"]));
+
+      const task = createTask("task-1", ["test"]);
+      const result = await router.route(task, executor);
+
+      expect(result.agentId).toBe("agent-2");
+      expect(result.status).toBe("success");
+    });
+
+    it("should return failed result when no agent available", async () => {
+      const task = createTask("task-1", ["nonexistent"]);
+      const result = await router.route(task, executor);
+
+      expect(result.status).toBe("failed");
+      expect(result.output).toEqual({ error: expect.stringContaining("No agent") });
+    });
+
+    it("should track statistics", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      registry.register(createAgent("agent-2", ["test"]));
+
+      await router.route(createTask("task-1", ["code"]), executor);
+      await router.route(createTask("task-2", ["test"]), executor);
+      await router.route(createTask("task-3", ["code"]), executor);
+
+      const stats = router.getStats();
+      expect(stats.tasksRouted).toBe(3);
+      expect(stats.byAgent["agent-1"]).toBe(2);
+      expect(stats.byAgent["agent-2"]).toBe(1);
+    });
+
+    it("should track failures", async () => {
+      await router.route(createTask("task-1", ["nonexistent"]), executor);
+
+      const stats = router.getStats();
+      expect(stats.failures).toBe(1);
+    });
+  });
+
+  describe("team routing", () => {
+    it("should route to team for multiple capabilities", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      registry.register(createAgent("agent-2", ["test"]));
+      registry.register(createAgent("agent-3", ["deploy"]));
+
+      const task = createTask("task-1", ["code", "test", "deploy"]);
+      const result = await router.route(task, executor);
+
+      expect(result.status).toBe("success");
+      expect(result.subtasks).toBeDefined();
+      expect(result.subtasks?.length).toBe(3);
+
+      const stats = router.getStats();
+      expect(stats.byTeam).toBe(1);
+    });
+
+    it("should route to single agent if team size is 1", async () => {
+      registry.register(createAgent("agent-1", ["code", "test", "deploy"]));
+
+      const task = createTask("task-1", ["code", "test"]);
+      const result = await router.route(task, executor);
+
+      expect(result.agentId).toBe("agent-1");
+      expect(result.subtasks).toBeUndefined();
+    });
+
+    it("should route to team when requiresTeam is true", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      registry.register(createAgent("agent-2", ["code"]));
+
+      const task = createTask("task-1", ["code"], true);
+      const result = await router.route(task, executor);
+
+      expect(result.status).toBe("success");
+    });
+  });
+
+  describe("load management", () => {
+    it("should increment load during execution", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      
+      let loadDuringExecution = -1;
+      const trackingExecutor: TaskExecutor = {
+        execute: async (agent, task) => {
+          loadDuringExecution = registry.get("agent-1")?.currentLoad ?? -1;
+          return { done: true };
+        },
+      };
+
+      await router.route(createTask("task-1", ["code"]), trackingExecutor);
+
+      expect(loadDuringExecution).toBe(1);
+      expect(registry.get("agent-1")?.currentLoad).toBe(0);
+    });
+
+    it("should decrement load after error", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      
+      const errorExecutor: TaskExecutor = {
+        execute: async () => {
+          throw new Error("Execution failed");
+        },
+      };
+
+      const result = await router.route(createTask("task-1", ["code"]), errorExecutor);
+
+      expect(result.status).toBe("failed");
+      expect(registry.get("agent-1")?.currentLoad).toBe(0);
+    });
+  });
+
+  describe("decomposition", () => {
+    it("should decompose task by capabilities", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      registry.register(createAgent("agent-2", ["test"]));
+      registry.register(createAgent("agent-3", ["deploy"]));
+
+      const task = createTask("task-1", ["code", "test", "deploy"]);
+      const result = await router.route(task, executor);
+
+      expect(result.subtasks).toBeDefined();
+      expect(result.subtasks?.length).toBe(3);
+      expect(result.subtasks?.map(s => s.agentId)).toContain("agent-1");
+      expect(result.subtasks?.map(s => s.agentId)).toContain("agent-2");
+      expect(result.subtasks?.map(s => s.agentId)).toContain("agent-3");
+    });
+  });
+
+  describe("synthesis", () => {
+    it("should synthesize results from team", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+      registry.register(createAgent("agent-2", ["test"]));
+
+      const task = createTask("task-1", ["code", "test"]);
+      const result = await router.route(task, executor);
+
+      expect(result.output).toHaveProperty("synthesized");
+      expect(result.output).toHaveProperty("results");
+    });
+  });
+
+  describe("DefaultTaskExecutor", () => {
+    it("should execute and return result", async () => {
+      const exec = new DefaultTaskExecutor();
+      const agent = createAgent("agent-1", ["code"]);
+      const task = createTask("task-1", ["code"]);
+
+      const result = await exec.execute(agent, task);
+
+      expect(result).toHaveProperty("agentId", "agent-1");
+      expect(result).toHaveProperty("taskId", "task-1");
+      expect(result).toHaveProperty("result", "executed");
+    });
+  });
+
+  describe("reset", () => {
+    it("should reset statistics", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+
+      await router.route(createTask("task-1", ["code"]), executor);
+      router.reset();
+
+      const stats = router.getStats();
+      expect(stats.tasksRouted).toBe(0);
+      expect(stats.byAgent).toEqual({});
+      expect(stats.byTeam).toBe(0);
+      expect(stats.failures).toBe(0);
+    });
+  });
+
+  describe("average duration", () => {
+    it("should calculate average duration", async () => {
+      registry.register(createAgent("agent-1", ["code"]));
+
+      await router.route(createTask("task-1", ["code"]), executor);
+      await router.route(createTask("task-2", ["code"]), executor);
+
+      const stats = router.getStats();
+      expect(stats.averageDuration).toBeGreaterThanOrEqual(0);
+    });
+
+    it("should return 0 when no tasks routed", () => {
+      const stats = router.getStats();
+      expect(stats.averageDuration).toBe(0);
+    });
+  });
+});

package/src/agents/router.ts

@@ -0,0 +1,251 @@
+import { logger } from "../utils/logger.ts";
+import { eventBus } from "../events/event-bus.ts";
+import type { AgentRegistry, AgentDefinition, Task, TaskResult } from "./registry.ts";
+import type { InterAgentBus } from "./inter-agent-bus.ts";
+
+export interface DecompositionResult {
+  subtasks: Task[];
+  strategy: "parallel" | "sequential" | "mixed";
+}
+
+export interface SynthesisConfig {
+  method: "concat" | "summarize" | "hierarchical";
+  leadAgentId: string;
+}
+
+export interface RouterStats {
+  tasksRouted: number;
+  byAgent: Record<string, number>;
+  byTeam: number;
+  failures: number;
+  averageDuration: number;
+}
+
+export class TaskRouter {
+  private tasksRouted = 0;
+  private byAgent: Record<string, number> = {};
+  private byTeam = 0;
+  private failures = 0;
+  private totalDuration = 0;
+  private log = logger.child("task-router");
+
+  constructor(
+    private registry: AgentRegistry,
+    private bus: InterAgentBus
+  ) {}
+
+  async route(task: Task, executor: TaskExecutor): Promise<TaskResult> {
+    const startTime = Date.now();
+    this.tasksRouted++;
+
+    this.log.info(`Routing task: ${task.id}`, {
+      capabilities: task.requiredCapabilities,
+      requiresTeam: task.requiresTeam,
+    });
+
+    try {
+      let result: TaskResult;
+
+      if (task.requiresTeam || task.requiredCapabilities.length > 1) {
+        const team = this.registry.findTeamForTask(task);
+        
+        if (team.length > 1) {
+          result = await this.executeWithTeam(team, task, executor);
+          this.byTeam++;
+        } else if (team.length === 1) {
+          result = await this.executeWithAgent(team[0]!, task, executor);
+          this.byAgent[team[0]!.id] = (this.byAgent[team[0]!.id] ?? 0) + 1;
+        } else {
+          throw new Error(`No agents available for task ${task.id}`);
+        }
+      } else {
+        const agent = this.registry.findBestAgentForTask(task);
+        
+        if (!agent) {
+          throw new Error(`No agent available for capabilities: ${task.requiredCapabilities.join(", ")}`);
+        }
+
+        result = await this.executeWithAgent(agent, task, executor);
+        this.byAgent[agent.id] = (this.byAgent[agent.id] ?? 0) + 1;
+      }
+
+      const duration = Date.now() - startTime;
+      this.totalDuration += duration;
+
+      eventBus.emit("tool:completed", {
+        toolName: `task:${task.id}`,
+        result: result.status,
+        duration,
+        success: result.status === "success",
+      });
+
+      return result;
+    } catch (error) {
+      this.failures++;
+      this.log.error(`Task routing failed: ${task.id}`, {
+        error: (error as Error).message,
+      });
+
+      return {
+        taskId: task.id,
+        agentId: "router",
+        status: "failed",
+        output: { error: (error as Error).message },
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  private async executeWithAgent(
+    agent: AgentDefinition,
+    task: Task,
+    executor: TaskExecutor
+  ): Promise<TaskResult> {
+    this.registry.incrementLoad(agent.id);
+
+    const startTime = Date.now();
+
+    try {
+      const output = await executor.execute(agent, task);
+
+      return {
+        taskId: task.id,
+        agentId: agent.id,
+        status: "success",
+        output,
+        duration: Date.now() - startTime,
+      };
+    } finally {
+      this.registry.decrementLoad(agent.id);
+    }
+  }
+
+  private async executeWithTeam(
+    team: AgentDefinition[],
+    task: Task,
+    executor: TaskExecutor
+  ): Promise<TaskResult> {
+    const lead = team[0]!;
+    const startTime = Date.now();
+
+    this.log.info(`Executing task ${task.id} with team of ${team.length} agents`, {
+      lead: lead.id,
+      members: team.map((a) => a.id),
+    });
+
+    for (const agent of team) {
+      this.registry.incrementLoad(agent.id);
+    }
+
+    try {
+      const decomposition = await this.decomposeTask(lead, task, executor);
+
+      const results: TaskResult[] = [];
+      
+      for (const subtask of decomposition.subtasks) {
+        const agentIndex = results.length % team.length;
+        const agent = team[agentIndex]!;
+
+        const result = await this.executeWithAgent(agent, subtask, executor);
+        results.push(result);
+      }
+
+      const synthesized = await this.synthesizeResults(lead, results, executor);
+
+      return {
+        taskId: task.id,
+        agentId: lead.id,
+        status: results.every((r) => r.status === "success") ? "success" : "partial",
+        output: synthesized,
+        duration: Date.now() - startTime,
+        subtasks: results,
+      };
+    } finally {
+      for (const agent of team) {
+        this.registry.decrementLoad(agent.id);
+      }
+    }
+  }
+
+  private async decomposeTask(
+    lead: AgentDefinition,
+    task: Task,
+    executor: TaskExecutor
+  ): Promise<DecompositionResult> {
+    const subtasks: Task[] = [];
+
+    for (let i = 0; i < task.requiredCapabilities.length; i++) {
+      const capability = task.requiredCapabilities[i]!;
+      subtasks.push({
+        id: `${task.id}-${i}`,
+        description: `Subtask for ${capability}`,
+        requiredCapabilities: [capability],
+        priority: task.priority,
+        parentTaskId: task.id,
+      });
+    }
+
+    return {
+      subtasks,
+      strategy: "parallel",
+    };
+  }
+
+  private async synthesizeResults(
+    lead: AgentDefinition,
+    results: TaskResult[],
+    executor: TaskExecutor
+  ): Promise<unknown> {
+    if (results.length === 1) {
+      return results[0]!.output;
+    }
+
+    return {
+      synthesized: true,
+      results: results.map((r) => ({
+        agentId: r.agentId,
+        status: r.status,
+        output: r.output,
+      })),
+    };
+  }
+
+  getStats(): RouterStats {
+    return {
+      tasksRouted: this.tasksRouted,
+      byAgent: { ...this.byAgent },
+      byTeam: this.byTeam,
+      failures: this.failures,
+      averageDuration: this.tasksRouted > 0 
+        ? this.totalDuration / this.tasksRouted 
+        : 0,
+    };
+  }
+
+  reset(): void {
+    this.tasksRouted = 0;
+    this.byAgent = {};
+    this.byTeam = 0;
+    this.failures = 0;
+    this.totalDuration = 0;
+  }
+}
+
+export interface TaskExecutor {
+  execute(agent: AgentDefinition, task: Task): Promise<unknown>;
+}
+
+export class DefaultTaskExecutor implements TaskExecutor {
+  private log = logger.child("task-executor");
+
+  async execute(agent: AgentDefinition, task: Task): Promise<unknown> {
+    this.log.info(`Executing task ${task.id} with agent ${agent.id}`);
+
+    return {
+      agentId: agent.id,
+      taskId: task.id,
+      result: "executed",
+      timestamp: Date.now(),
+    };
+  }
+}