@c4ccz/zero 1.0.0 → 1.0.1

package/packages/core/src/sub-agent/index.ts

@@ -0,0 +1,179 @@
+/**
+ * ZERO Sub-Agent System
+ * Adapted from: cline - Apache 2.0
+ *
+ * Full sub-agent delegation with config loading,
+ * tool scoping, and result aggregation.
+ */
+
+import type {
+  AgentConfig,
+  AgentResult,
+  Message,
+  ToolDefinition,
+  ToolResult,
+  PermissionHandler,
+  LLMClient,
+} from "../types.js";
+import { AgentEngine } from "../agent/engine.js";
+
+export interface SubAgentTask {
+  agentId: string;
+  task: string;
+  context?: string;
+  maxTurns?: number;
+}
+
+export interface SubAgentResult {
+  agentId: string;
+  success: boolean;
+  output: string;
+  tokenUsage: { inputTokens: number; outputTokens: number };
+  duration: number;
+  error?: string;
+}
+
+export interface SubAgentOptions {
+  agents: Map<string, AgentConfig>;
+  tools: Map<string, ToolDefinition>;
+  clientFactory: (model: string) => LLMClient;
+  permissionHandler: PermissionHandler;
+  workingDirectory: string;
+  sessionId: string;
+}
+
+/**
+ * Sub-Agent Manager
+ */
+export class SubAgentManager {
+  private options: SubAgentOptions;
+
+  constructor(options: SubAgentOptions) {
+    this.options = options;
+  }
+
+  /**
+   * Execute a task with a specific sub-agent
+   */
+  async execute(task: SubAgentTask): Promise<SubAgentResult> {
+    const agentConfig = this.options.agents.get(task.agentId);
+    if (!agentConfig) {
+      return {
+        agentId: task.agentId,
+        success: false,
+        output: "",
+        tokenUsage: { inputTokens: 0, outputTokens: 0 },
+        duration: 0,
+        error: `Agent "${task.agentId}" not found`,
+      };
+    }
+
+    const config: AgentConfig = {
+      ...agentConfig,
+      maxTurns: task.maxTurns || agentConfig.maxTurns || 20,
+    };
+
+    const engine = new AgentEngine({
+      config,
+      client: this.options.clientFactory(config.model),
+      tools: this.getScopedTools(config.tools),
+      permissionHandler: this.options.permissionHandler,
+      workingDirectory: this.options.workingDirectory,
+      sessionId: `${this.options.sessionId}_sub_${task.agentId}`,
+    });
+
+    const prompt = task.context
+      ? `${task.task}\n\n## Context:\n${task.context}`
+      : task.task;
+
+    const result = await engine.run(prompt);
+
+    return {
+      agentId: task.agentId,
+      success: result.success,
+      output: this.extractOutput(result),
+      tokenUsage: result.tokenUsage,
+      duration: result.duration,
+      error: result.error,
+    };
+  }
+
+  /**
+   * Execute multiple tasks in parallel
+   */
+  async executeParallel(tasks: SubAgentTask[]): Promise<SubAgentResult[]> {
+    return Promise.all(tasks.map((task) => this.execute(task)));
+  }
+
+  /**
+   * Execute tasks sequentially
+   */
+  async executeSequential(tasks: SubAgentTask[]): Promise<SubAgentResult[]> {
+    const results: SubAgentResult[] = [];
+    for (const task of tasks) {
+      results.push(await this.execute(task));
+    }
+    return results;
+  }
+
+  private getScopedTools(toolNames: string[]): Map<string, ToolDefinition> {
+    const scoped = new Map<string, ToolDefinition>();
+    for (const name of toolNames) {
+      const tool = this.options.tools.get(name);
+      if (tool) scoped.set(name, tool);
+    }
+    return scoped;
+  }
+
+  private extractOutput(result: AgentResult): string {
+    return result.messages
+      .filter((m) => m.role === "assistant")
+      .flatMap((m) => m.content)
+      .filter((c) => c.type === "text")
+      .map((c) => (c as any).text)
+      .join("\n");
+  }
+}
+
+/**
+ * Create a delegate_to_agent tool
+ */
+export function createDelegateTool(manager: SubAgentManager): ToolDefinition {
+  return {
+    name: "delegate_to_agent",
+    description: "Delegate a sub-task to a specialized agent. The sub-agent will work independently and return results.",
+    parameters: {
+      agentId: {
+        type: "string",
+        description: "ID of the agent to delegate to (reviewer, researcher)",
+        required: true,
+        enum: ["reviewer", "researcher"],
+      },
+      task: {
+        type: "string",
+        description: "The task description for the sub-agent",
+        required: true,
+      },
+      context: {
+        type: "string",
+        description: "Additional context for the sub-agent",
+        required: false,
+      },
+    },
+    category: "system",
+    requiresApproval: false,
+    handler: async (args): Promise<ToolResult> => {
+      const result = await manager.execute({
+        agentId: args.agentId as string,
+        task: args.task as string,
+        context: args.context as string | undefined,
+      });
+
+      return {
+        success: result.success,
+        output: result.output || result.error || "No output",
+        data: result,
+      };
+    },
+  };
+}