add subagent parallel tool

Author: uinstinct

extensions/cli/src/subagent/index.ts

@@ -26,3 +26,24 @@ export const SUBAGENT_TOOL_META: Tool = {
   },
   run: async () => "",
 };
+
+export const SUBAGENT_PARALLEL_TOOL_META: Tool = {
+  name: "SubagentParallel",
+  displayName: "Subagent Parallel",
+  description:
+    "Invoke multiple subagents in parallel and wait for all to complete.",
+  readonly: false,
+  isBuiltIn: true,
+  parameters: {
+    type: "object",
+    required: ["tasks"],
+    properties: {
+      tasks: {
+        type: "array",
+        description:
+          "Array of tasks to execute in parallel. Each task specifies a subagent and its prompt.",
+      },
+    },
+  },
+  run: async () => "",
+};

extensions/cli/src/tools/allBuiltIns.ts

@@ -1,4 +1,7 @@
-import { SUBAGENT_TOOL_META } from "../subagent/index.js";
+import {
+  SUBAGENT_PARALLEL_TOOL_META,
+  SUBAGENT_TOOL_META,
+} from "../subagent/index.js";
 
 import { askQuestionTool } from "./askQuestion.js";
 import { editTool } from "./edit.js";
@@ -31,6 +34,7 @@ export const ALL_BUILT_IN_TOOLS = [
   searchCodeTool,
   statusTool,
   SUBAGENT_TOOL_META,
+  SUBAGENT_PARALLEL_TOOL_META,
   SKILLS_TOOL_META,
   uploadArtifactTool,
   viewDiffTool,

extensions/cli/src/tools/index.tsx

@@ -31,7 +31,7 @@ import { reportFailureTool } from "./reportFailure.js";
 import { runTerminalCommandTool } from "./runTerminalCommand.js";
 import { checkIfRipgrepIsInstalled, searchCodeTool } from "./searchCode.js";
 import { skillsTool } from "./skills.js";
-import { subagentTool } from "./subagent.js";
+import { subagentParallelTool, subagentTool } from "./subagent.js";
 import { isBetaUploadArtifactToolEnabled } from "./toolsConfig.js";
 import {
   type Tool,
@@ -127,6 +127,7 @@ export async function getAllAvailableTools(
   }
 
   tools.push(await subagentTool());
+  tools.push(await subagentParallelTool());
 
   tools.push(await skillsTool());
 

extensions/cli/src/tools/subagent.ts

@@ -7,11 +7,20 @@ import {
   getSubagent,
   getAgentNames as getSubagentNames,
 } from "../subagent/get-agents.js";
-import { SUBAGENT_TOOL_META } from "../subagent/index.js";
+import {
+  SUBAGENT_PARALLEL_TOOL_META,
+  SUBAGENT_TOOL_META,
+} from "../subagent/index.js";
 import { logger } from "../util/logger.js";
 
 import { Tool } from "./types.js";
 
+interface SubagentTask {
+  description: string;
+  prompt: string;
+  subagent_name: string;
+}
+
 export const subagentTool = async (): Promise<Tool> => {
   const modelServiceState = await serviceContainer.get<ModelServiceState>(
     SERVICE_NAMES.MODEL,
@@ -99,3 +108,138 @@ export const subagentTool = async (): Promise<Tool> => {
     },
   };
 };
+
+export const subagentParallelTool = async (): Promise<Tool> => {
+  const modelServiceState = await serviceContainer.get<ModelServiceState>(
+    SERVICE_NAMES.MODEL,
+  );
+
+  const availableAgents = modelServiceState
+    ? getSubagentNames(modelServiceState).join(", ")
+    : "";
+
+  return {
+    ...SUBAGENT_PARALLEL_TOOL_META,
+
+    description: `Invoke multiple subagents in parallel and wait for all to complete. Use this when you have multiple independent tasks that can be executed concurrently. Available agents: ${availableAgents}`,
+
+    parameters: {
+      ...SUBAGENT_PARALLEL_TOOL_META.parameters,
+      properties: {
+        tasks: {
+          ...SUBAGENT_PARALLEL_TOOL_META.parameters.properties.tasks,
+          items: {
+            type: "object",
+            required: ["description", "prompt", "subagent_name"],
+            properties: {
+              ...SUBAGENT_TOOL_META.parameters.properties,
+              subagent_name: {
+                type: "string",
+                description: `The type of specialized agent to use. Available: ${availableAgents}`,
+              },
+            },
+          },
+        },
+      },
+    },
+
+    preprocess: async (args: any) => {
+      const { tasks } = args as { tasks: SubagentTask[] };
+
+      if (!Array.isArray(tasks) || tasks.length === 0) {
+        throw new Error("tasks must be a non-empty array");
+      }
+
+      const previews: { type: string; content: string }[] = [];
+
+      for (const task of tasks) {
+        const agent = getSubagent(modelServiceState, task.subagent_name);
+        if (!agent) {
+          throw new Error(
+            `Unknown agent type: ${task.subagent_name}. Available agents: ${availableAgents}`,
+          );
+        }
+        previews.push({
+          type: "text",
+          content: `Spawning ${agent.model.name} to: ${task.description}`,
+        });
+      }
+
+      return {
+        args,
+        preview: [
+          {
+            type: "text",
+            content: `Spawning ${tasks.length} subagents in parallel:\n${previews.map((p) => `  - ${p.content}`).join("\n")}`,
+          },
+        ],
+      };
+    },
+
+    run: async (args: any, context?: { toolCallId: string }) => {
+      const { tasks } = args as { tasks: SubagentTask[] };
+
+      logger.debug("subagent_parallel args", { args, context });
+
+      const chatHistoryService = services.chatHistory;
+      const parentSessionId = chatHistoryService.getSessionId();
+      if (!parentSessionId) {
+        throw new Error("No active session found");
+      }
+
+      const executeTask = async (task: SubagentTask, index: number) => {
+        const agent = getSubagent(modelServiceState, task.subagent_name);
+        if (!agent) {
+          return {
+            index,
+            description: task.description,
+            success: false,
+            response: `Unknown agent type: ${task.subagent_name}`,
+          };
+        }
+
+        try {
+          const result = await subAgentService.executeSubAgent({
+            agent,
+            prompt: task.prompt,
+            parentSessionId,
+            abortController: new AbortController(),
+          });
+
+          return {
+            index,
+            description: task.description,
+            success: result.success,
+            response: result.response,
+          };
+        } catch (error) {
+          return {
+            index,
+            description: task.description,
+            success: false,
+            response: `Error: ${error instanceof Error ? error.message : String(error)}`,
+          };
+        }
+      };
+
+      const results = await Promise.all(
+        tasks.map((task, index) => executeTask(task, index)),
+      );
+
+      logger.debug("subagent_parallel results", { results });
+
+      const outputParts = results.map((result) => {
+        return [
+          `<task index="${result.index}" description="${result.description}">`,
+          result.response,
+          `<task_metadata>`,
+          `status: ${result.success ? "completed" : "failed"}`,
+          `</task_metadata>`,
+          `</task>`,
+        ].join("\n");
+      });
+
+      return outputParts.join("\n\n");
+    },
+  };
+};