@khalilgharbaoui/opencode-claude-code-plugin 0.16.0 → 0.17.0

package/README.md

@@ -357,7 +357,7 @@ By default, the plugin proxies `Bash`, `Edit`, `Write`, `WebFetch`, and `Task`.
 | `"Edit"` | `Edit`, `MultiEdit` | `mcp__opencode_proxy__edit` |
 | `"Write"` | `Write` | `mcp__opencode_proxy__write` |
 | `"WebFetch"` | `WebFetch` | `mcp__opencode_proxy__webfetch` |
-| `"Task"` | `Agent` | `mcp__opencode_proxy__task` |
+| `"Task"` | `Agent` | `mcp__opencode_proxy__task`, `mcp__opencode_proxy__task_batch` |
 | `"Question"` | `AskUserQuestion` | `mcp__opencode_proxy__question` |
 | `"Compress"` | none | `mcp__opencode_proxy__compress` |
 
@@ -369,6 +369,7 @@ By default, the plugin proxies `Bash`, `Edit`, `Write`, `WebFetch`, and `Task`.
 - **Resume:** pass the child session ID back as `task_id` to continue that subagent session. Omit it to create a fresh child.
 - **Nested tasks:** current opencode defaults `subagent_depth` to `1`, so a first-level child cannot launch another child. Increase top-level `subagent_depth` to permit deeper nesting, and explicitly grant `permission.task` on every subagent that should delegate; opencode otherwise adds a task deny to spawned subagent sessions.
 - **Background:** `background: true` returns after starting the child and lets opencode notify the parent when it finishes. Current opencode requires `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` in the environment of the opencode process. Foreground is the default.
+- **Several at once:** `mcp__opencode_proxy__task_batch` takes a `tasks` array of ordinary task inputs and runs them concurrently. It exists because Claude Code sends MCP requests one at a time: when the model emits two `task` calls in one response, the second only leaves the CLI after the first has returned (measured live, 2026-09-06), so "launch two subagents" was always serial. The plugin turns one `task_batch` call into N opencode `task` calls inside a single tool boundary, which opencode executes in parallel, then hands the model every result together, labelled in task order. Same permissions, same 60-minute deadline, same `subagent_type` list. Enabled whenever `Task` is proxied. Designed and first implemented by [@broskees](https://github.com/broskees) on his fork.
 
 **Steering models to it.** Headless Claude Code CLIs expose no `Agent`/`Task`
 dispatch tool of their own (verified on 2.1.211), while they *do* expose
@@ -965,7 +966,7 @@ This plugin absorbs work from its forks directly, cherry-picked with the origina
 | [@galvani](https://github.com/galvani) (Jan Kozak) | Per-session working directory for `opencode serve`, so one server spawns each project's `claude` in the right place. Also found the stale `toolCallMap` re-emission three months before it was fixed here. | `9e02ce4`, `2238ed0` |
 | [@HeikoAtGitHub](https://github.com/HeikoAtGitHub) | Stopped sending `AGENTS.md` to the model twice (opencode already forwards it). Independently diagnosed the 5-minute proxy wall. | `25260a4`, `42f426d` |
 | [@bernardofortes](https://github.com/bernardofortes) (Bernardo Fortes) | `idleProcessTimeoutMs`, idle eviction of retained `claude` workers. | `a5f723a` |
-| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, and the undici 300 s diagnosis of the proxy wall. | PR #18, `68ed142` |
+| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, `task_batch` for concurrent subagents (and the measurement that the CLI serialises MCP calls), and the undici 300 s diagnosis of the proxy wall. | PR #18, `68ed142` |
 | [@jknlsn](https://github.com/jknlsn) (Jake Nelson) | Per-tool proxy timeouts, subagent dispatch steering, the question proxy, the start watchdog respawn. | `84f3db9`, `94980a6`, `47501d0`, `ffefc24` |
 | [@CollieIsCute](https://github.com/CollieIsCute) (Collie Tsai) | The plan-mode approval bridge. | `8c5b583` |
 | [@flupkede](https://github.com/flupkede) | The compress proxy tool design and the AI-SDK v4 image-part fix. | `4ac319f`, `60a6e9a` |

package/dist/index.d.ts

@@ -630,6 +630,16 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      */
     private ensureProxyServer;
     private extractPendingProxyResult;
+    /**
+     * The result opencode produced for a pending proxy call, if the prompt
+     * carries it. For `task_batch` that means every child's result gathered
+     * back onto the parent: opencode runs the children in one step and hands
+     * all their results to the next call together, so a partial set is not
+     * expected. If it ever happens the batch still resolves, with the gap
+     * named in the text, because leaving the parent pending would send this
+     * turn down the fresh-envelope path and reject the call as orphaned.
+     */
+    private extractPendingProxyResultForCall;
     /**
      * Resolve the session affinity token for this LLM call. Delegates to the
      * exported `resolveSessionAffinity` helper so the logic is unit-testable.

package/dist/index.js

@@ -523,6 +523,8 @@ var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 var PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS = {
   task: 60 * 60 * 1e3,
   // 60 min
+  task_batch: 60 * 60 * 1e3,
+  // 60 min, same reasoning: it IS task calls
   question: 30 * 60 * 1e3
   // 30 min
 };
@@ -562,14 +564,58 @@ function resolveProxyClientCeilingMs(overrides) {
 function buildProxyTimeoutError(toolName, ms) {
   const key = toolName.toLowerCase();
   const base = `Proxy tool '${toolName}' timed out after ${ms}ms waiting for opencode to resolve the call`;
-  if (key === "task") {
+  if (key === "task" || key === TASK_BATCH_TOOL_NAME) {
     return new Error(
-      base + " (the subagent). The subagent may still be running but its result is no longer reachable in this session. Do not declare the dispatch failed, and do not 'schedule a wake-up' or defer -- that mechanism does not apply here. If the result is required, re-dispatch or verify it directly now."
+      base + (key === "task" ? " (the subagent)." : " (the subagents).") + " The subagent may still be running but its result is no longer reachable in this session. Do not declare the dispatch failed, and do not 'schedule a wake-up' or defer -- that mechanism does not apply here. If the result is required, re-dispatch or verify it directly now."
     );
   }
   return new Error(base);
 }
-var TASK_PROXY_NOTE = "This is the ONLY tool that dispatches opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists \u2014 invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
+var TASK_PROXY_NOTE = "This and task_batch are the ONLY tools that dispatch opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists: invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
+var TASK_BATCH_TOOL_NAME = "task_batch";
+var TASK_BATCH_PROXY_NOTE = "Use this instead of several task calls in one response: Claude Code runs MCP tool calls one at a time, so separate task calls run serially even when emitted together, while one task_batch call fans them out as parallel opencode task calls. Each task takes the same fields as the task tool. Results come back in task order, each labelled. Same 60-minute proxy deadline as task (configurable via proxyToolTimeoutMs).";
+var TASK_INPUT_REQUIRED = ["description", "prompt", "subagent_type"];
+function taskBatchInputError(input) {
+  const tasks = input?.tasks;
+  if (!Array.isArray(tasks) || tasks.length < 2) {
+    return "task_batch requires a `tasks` array with at least two items; use `task` for one subagent";
+  }
+  for (const [index, task] of tasks.entries()) {
+    if (task === null || typeof task !== "object" || Array.isArray(task)) {
+      return `task_batch tasks[${index}] must be an object`;
+    }
+    const item = task;
+    for (const field of TASK_INPUT_REQUIRED) {
+      if (typeof item[field] !== "string") {
+        return `task_batch tasks[${index}].${field} must be a string`;
+      }
+    }
+  }
+  return null;
+}
+function taskBatchTasks(input) {
+  if (taskBatchInputError(input)) return [];
+  return input.tasks;
+}
+function taskBatchChildToolCallId(parentToolCallId, index) {
+  return `${parentToolCallId}_task_${index}`;
+}
+function formatTaskBatchResults(children) {
+  const total = children.length;
+  const sections = children.map(({ task, result }, index) => {
+    const label = typeof task.description === "string" ? task.description : `task ${index + 1}`;
+    const agent = typeof task.subagent_type === "string" ? ` (${task.subagent_type})` : "";
+    const header = `## task ${index + 1} of ${total}: ${label}${agent}`;
+    if (!result) return `${header}
+[missing] opencode returned no result for this task in the batch`;
+    if (result.kind === "error") return `${header}
+[error] ${result.message}`;
+    return `${header}
+${result.isError ? "[error] " : ""}${result.text}`;
+  });
+  const failed = children.some(({ result }) => !result || result.kind === "error" || result.isError);
+  return { kind: "text", text: sections.join("\n\n"), ...failed ? { isError: true } : {} };
+}
 var AGENT_TYPES_HEADING = "Available agent types";
 var AGENT_BLURB_LIMIT = 140;
 var QUESTION_PROXY_NOTE = "This routes structured questions through opencode's native `question` tool, which renders a TUI form with the options you provide and blocks until the operator answers. Claude Code's built-in AskUserQuestion is disabled in this environment; this proxy is the ONLY way to ask the operator for a decision or clarification. Answers come back as arrays of selected labels (set `multiple: true` to allow more than one). If the operator dismisses the form the call returns an error \u2014 treat that as 'no answer' and stop, do not guess. Question calls get a 30-minute proxy deadline by default (configurable via proxyToolTimeoutMs); for long-AFK scenarios prefer fewer, high-signal questions.";
@@ -597,7 +643,7 @@ function overlayTaskProxyDescription(tools, liveDescription) {
   const agentTypes = extractAgentTypeList(liveDescription);
   if (!agentTypes) return tools;
   return tools.map(
-    (t) => t.name === "task" ? { ...t, description: `${agentTypes}
+    (t) => t.name === "task" || t.name === TASK_BATCH_TOOL_NAME ? { ...t, description: `${agentTypes}
 
 ${t.description}` } : t
   );
@@ -615,6 +661,32 @@ function filterQuestionProxyByOpencodeSupport(tools, opencodeHasQuestion) {
   if (opencodeHasQuestion) return tools;
   return tools.filter((t) => t.name !== "question");
 }
+var TASK_INPUT_PROPERTIES = {
+  description: {
+    type: "string",
+    description: "A short (3-5 words) description of the task"
+  },
+  prompt: {
+    type: "string",
+    description: "The task for the agent to perform"
+  },
+  subagent_type: {
+    type: "string",
+    description: "The type of specialized agent to use for this task"
+  },
+  task_id: {
+    type: "string",
+    description: "Set this only if you mean to resume a previous task: pass the prior task_id to continue the same subagent session instead of creating a fresh one."
+  },
+  command: {
+    type: "string",
+    description: "The command that triggered this task"
+  },
+  background: {
+    type: "boolean",
+    description: "Run the task in the background when supported by opencode"
+  }
+};
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -708,35 +780,30 @@ var DEFAULT_PROXY_TOOLS = [
   {
     name: "task",
     description: "Launch an opencode subagent to handle a complex multi-step task autonomously. Routed through opencode's task tool so subagent orchestration, permission, and lifecycle are handled by opencode. Use `subagent_type` to pick which configured subagent runs (e.g. `build`, `general`, `explore`, or any custom subagent declared in opencode.json). " + TASK_PROXY_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: TASK_INPUT_PROPERTIES,
+      required: TASK_INPUT_REQUIRED
+    }
+  },
+  {
+    name: TASK_BATCH_TOOL_NAME,
+    description: "Launch two or more independent opencode subagents at the same time and get all their results back together. Put one ordinary task input in `tasks` for each subagent. " + TASK_BATCH_PROXY_NOTE,
     inputSchema: {
       type: "object",
       properties: {
-        description: {
-          type: "string",
-          description: "A short (3-5 words) description of the task"
-        },
-        prompt: {
-          type: "string",
-          description: "The task for the agent to perform"
-        },
-        subagent_type: {
-          type: "string",
-          description: "The type of specialized agent to use for this task"
-        },
-        task_id: {
-          type: "string",
-          description: "Set this only if you mean to resume a previous task \u2014 pass the prior task_id to continue the same subagent session instead of creating a fresh one."
-        },
-        command: {
-          type: "string",
-          description: "The command that triggered this task"
-        },
-        background: {
-          type: "boolean",
-          description: "Run the task in the background when supported by opencode"
+        tasks: {
+          type: "array",
+          minItems: 2,
+          description: "Independent subagent tasks to run concurrently",
+          items: {
+            type: "object",
+            properties: TASK_INPUT_PROPERTIES,
+            required: TASK_INPUT_REQUIRED
+          }
         }
       },
-      required: ["description", "prompt", "subagent_type"]
+      required: ["tasks"]
     }
   },
   {
@@ -922,6 +989,13 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           });
           return;
         }
+        if (toolName === TASK_BATCH_TOOL_NAME) {
+          const problem = taskBatchInputError(input);
+          if (problem) {
+            writeToolCallResult(res, requestId, { kind: "error", message: problem });
+            return;
+          }
+        }
         const interceptor = interceptors?.get(toolName);
         if (interceptor) {
           let intercepted;
@@ -1126,6 +1200,7 @@ function disallowedToolFlags(tools) {
     grep: ["Grep"],
     webfetch: ["WebFetch"],
     task: ["Agent"],
+    task_batch: ["Agent"],
     // `question` disables Claude Code's built-in `AskUserQuestion` so the
     // structured-questions path flows through opencode's native `question`
     // tool instead — same UI/permission/audit benefits as the other
@@ -4599,8 +4674,9 @@ blocker. The user can interrupt or abort at any time; turn endings should
 mark meaningful checkpoints, not every completed substep.`;
 var SUBAGENT_DISPATCH_HINT = `## opencode subagents
 
-Subagent dispatch in this environment goes through exactly one tool: \`mcp__opencode_proxy__task\`.
+Subagent dispatch in this environment goes through exactly two tools: \`mcp__opencode_proxy__task\` for one subagent and \`mcp__opencode_proxy__task_batch\` for two or more at once.
 
+- Two or more independent subagents in one response: make ONE \`mcp__opencode_proxy__task_batch\` call with a \`tasks\` array (each item is a normal task input). Claude Code runs MCP calls one at a time, so several \`mcp__opencode_proxy__task\` calls in the same response run serially; \`task_batch\` runs them concurrently in opencode and returns every result together, labelled in order.
 - When the user mentions \`@<agent>\` or an instruction says "call the task tool with subagent: <name>", call \`mcp__opencode_proxy__task\` with \`subagent_type: "<name>"\`.
 - If that tool is not in your visible tool list it is deferred \u2014 load it with ToolSearch (\`select:mcp__opencode_proxy__task\`), then call it.
 - Claude Code's built-in TaskCreate/TaskUpdate/TaskList manage a local todo list. They cannot dispatch subagents; creating a task there runs nothing. Never report a subagent as dispatched unless \`mcp__opencode_proxy__task\` returned its result.
@@ -4804,11 +4880,24 @@ var ClaudeCodeLanguageModel = class {
       DEFAULT_PROXY_TOOLS.map((t) => [t.name.toLowerCase(), t])
     );
     const picked = [];
+    const seen = /* @__PURE__ */ new Set();
     const unknown = [];
+    const pick = (def) => {
+      if (seen.has(def.name)) return;
+      seen.add(def.name);
+      picked.push(def);
+    };
     for (const n of names) {
       const def = defsByName.get(String(n).toLowerCase());
-      if (def) picked.push(def);
-      else unknown.push(String(n));
+      if (!def) {
+        unknown.push(String(n));
+        continue;
+      }
+      pick(def);
+      if (def.name === "task") {
+        const batch = defsByName.get(TASK_BATCH_TOOL_NAME);
+        if (batch) pick(batch);
+      }
     }
     if (unknown.length > 0) {
       const known = [...defsByName.keys()].join(", ");
@@ -4998,6 +5087,41 @@ var ClaudeCodeLanguageModel = class {
     }
     return null;
   }
+  /**
+   * The result opencode produced for a pending proxy call, if the prompt
+   * carries it. For `task_batch` that means every child's result gathered
+   * back onto the parent: opencode runs the children in one step and hands
+   * all their results to the next call together, so a partial set is not
+   * expected. If it ever happens the batch still resolves, with the gap
+   * named in the text, because leaving the parent pending would send this
+   * turn down the fresh-envelope path and reject the call as orphaned.
+   */
+  extractPendingProxyResultForCall(prompt, call) {
+    if (call.toolName !== TASK_BATCH_TOOL_NAME) {
+      return this.extractPendingProxyResult(prompt, call.toolCallId);
+    }
+    const tasks = taskBatchTasks(call.input);
+    if (tasks.length === 0) {
+      return { kind: "error", message: "task_batch input is not a list of task objects" };
+    }
+    const children = tasks.map((task, index) => ({
+      task,
+      result: this.extractPendingProxyResult(
+        prompt,
+        taskBatchChildToolCallId(call.toolCallId, index)
+      )
+    }));
+    const answered = children.filter((child) => child.result !== null).length;
+    if (answered === 0) return null;
+    if (answered < children.length) {
+      log.warn("task_batch resolving with child results missing", {
+        toolCallId: call.toolCallId,
+        answered,
+        total: children.length
+      });
+    }
+    return formatTaskBatchResults(children);
+  }
   /**
    * Resolve the session affinity token for this LLM call. Delegates to the
    * exported `resolveSessionAffinity` helper so the logic is unit-testable.
@@ -5809,7 +5933,7 @@ ${plan}
     const self = this;
     const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
       call,
-      result: this.extractPendingProxyResult(options.prompt, call.toolCallId)
+      result: this.extractPendingProxyResultForCall(options.prompt, call)
     }));
     const hasMatchedPendingResults = previousPendingProxyMatches.some(
       (m) => m.result !== null
@@ -6271,20 +6395,34 @@ ${plan}
           const finishWithToolCalls = (calls) => {
             if (controllerClosed) return;
             if (calls.length === 0) return;
-            for (const call of calls) {
+            const enqueueToolCall = (toolCallId, toolName, input) => {
               controller.enqueue({
                 type: "tool-input-start",
-                id: call.toolCallId,
-                toolName: call.toolName
+                id: toolCallId,
+                toolName
               });
               controller.enqueue({
                 type: "tool-call",
-                toolCallId: call.toolCallId,
-                toolName: call.toolName,
-                input: JSON.stringify(call.input),
+                toolCallId,
+                toolName,
+                input: JSON.stringify(input),
                 providerExecuted: false
               });
-              skipResultForIds.add(call.toolCallId);
+              skipResultForIds.add(toolCallId);
+            };
+            for (const call of calls) {
+              if (call.toolName === TASK_BATCH_TOOL_NAME) {
+                for (const [index, task] of taskBatchTasks(call.input).entries()) {
+                  enqueueToolCall(
+                    taskBatchChildToolCallId(call.toolCallId, index),
+                    "task",
+                    task
+                  );
+                }
+                skipResultForIds.add(call.toolCallId);
+              } else {
+                enqueueToolCall(call.toolCallId, call.toolName, call.input);
+              }
               markPendingProxyCallEmitted(call.toolCallId);
             }
             controller.enqueue({