@khalilgharbaoui/opencode-claude-code-plugin 0.4.21 → 0.4.23

package/README.md

@@ -213,8 +213,11 @@ By default, when Claude Code's CLI uses `Bash`, `Edit`, `Write`, etc., it execut
 | `"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` |
 
-Only those four values are actually proxied; anything else you put in `proxyTools` is ignored. Proxying `Edit` also disables `MultiEdit` — opencode has no batched-edit equivalent, so Claude is forced to fan out into single `Edit` calls that each flow through the permission UI.
+The `Task` proxy is the way to let Claude orchestrate opencode's configured subagents (`build`, `general`, custom subagents defined in `opencode.json`) instead of Claude CLI's internal-only general-purpose / Explore / Plan options. With `"Task"` in `proxyTools` and `permission.task: allow` granted to the calling agent, a Claude session can invoke `task(subagent_type="build", prompt="...")` and the subagent runs natively under opencode (with its own permission UI, lifecycle, model assignment, and Tab visibility). Without `"Task"`, Claude's built-in `Agent` tool stays enabled and Claude orchestrates subagents internally with no opencode visibility.
+
+Only those five values are actually proxied; anything else you put in `proxyTools` is ignored. Proxying `Edit` also disables `MultiEdit` — opencode has no batched-edit equivalent, so Claude is forced to fan out into single `Edit` calls that each flow through the permission UI.
 
 To turn off proxying entirely:
 

package/dist/index.d.ts

@@ -229,7 +229,15 @@ interface ClaudeCodeProviderSettings {
      *     opencode's tool executor (with its native permission UI) and returns
      *     the result.
      *
-     * Supported: `bash`, `write`, `edit`, `webfetch`. Leave empty or unset to disable proxying.
+     * Supported: `bash`, `write`, `edit`, `webfetch`, `task`. Leave empty or unset to disable proxying.
+     *
+     * `task` proxies Claude CLI's `Agent` (subagent dispatch) tool through
+     * opencode's `task` tool, so subagent calls run under opencode's
+     * configured subagent set (build/general/custom) with opencode's
+     * permission and lifecycle handling, instead of Claude CLI's
+     * internal-only general-purpose / Explore / Plan options. The calling
+     * agent must have `permission.task: allow` for the target subagent
+     * (see opencode's agent docs).
      */
     proxyTools?: string[];
     /**

package/dist/index.js

@@ -124,6 +124,91 @@ var log = {
   }
 };
 
+// src/todo-ledger.ts
+var ledgers = /* @__PURE__ */ new Map();
+var PENDING_CREATE_TTL_MS = 6e4;
+var TASK_CREATED_PATTERN = /Task\s*#?\s*(\d+)\s+created/i;
+var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
+function getOrCreate(sessionId) {
+  let ledger = ledgers.get(sessionId);
+  if (!ledger) {
+    ledger = { todos: /* @__PURE__ */ new Map(), pendingCreates: /* @__PURE__ */ new Map() };
+    ledgers.set(sessionId, ledger);
+  }
+  return ledger;
+}
+function prunePending(ledger) {
+  const cutoff = Date.now() - PENDING_CREATE_TTL_MS;
+  for (const [id, pending] of ledger.pendingCreates) {
+    if (pending.createdAt < cutoff) ledger.pendingCreates.delete(id);
+  }
+}
+function materialize(ledger) {
+  return Array.from(ledger.todos.values());
+}
+function resolveSubject(input) {
+  const subject = typeof input?.subject === "string" ? input.subject.trim() : "";
+  if (subject) return subject;
+  const description = typeof input?.description === "string" ? input.description.trim() : "";
+  if (description) return description;
+  return "(no subject)";
+}
+function applyTaskCreateToolUse(sessionId, toolUseId, input) {
+  if (!sessionId || !toolUseId) return;
+  const ledger = getOrCreate(sessionId);
+  prunePending(ledger);
+  ledger.pendingCreates.set(toolUseId, {
+    subject: resolveSubject(input),
+    createdAt: Date.now()
+  });
+}
+function applyTaskCreateToolResult(sessionId, toolUseId, resultText) {
+  if (!sessionId || !toolUseId) return null;
+  const ledger = ledgers.get(sessionId);
+  if (!ledger) return null;
+  const pending = ledger.pendingCreates.get(toolUseId);
+  if (!pending) return null;
+  ledger.pendingCreates.delete(toolUseId);
+  const match = typeof resultText === "string" ? resultText.match(TASK_CREATED_PATTERN) : null;
+  if (!match) {
+    log.debug("TaskCreate result did not match expected format", { sessionId, toolUseId, resultText });
+    return null;
+  }
+  const claudeId = match[1];
+  if (ledger.todos.has(claudeId)) {
+    log.debug("TaskCreate result for already-known claude id; overwriting", { sessionId, claudeId });
+  }
+  ledger.todos.set(claudeId, { id: claudeId, content: pending.subject, status: "pending" });
+  return materialize(ledger);
+}
+function applyTaskUpdate(sessionId, input) {
+  if (!sessionId) return null;
+  const taskId = typeof input?.taskId === "string" ? input.taskId : null;
+  if (!taskId) return null;
+  const ledger = ledgers.get(sessionId);
+  if (!ledger) return null;
+  const entry = ledger.todos.get(taskId);
+  if (!entry) {
+    log.debug("TaskUpdate for unknown task id", { sessionId, taskId });
+    return null;
+  }
+  if (input?.status === "deleted") {
+    ledger.todos.delete(taskId);
+    return materialize(ledger);
+  }
+  if (typeof input?.status === "string" && VALID_STATUSES.has(input.status)) {
+    entry.status = input.status;
+  }
+  if (typeof input?.subject === "string" && input.subject.trim().length > 0) {
+    entry.content = input.subject.trim();
+  }
+  return materialize(ledger);
+}
+function clearLedger(sessionId) {
+  if (!sessionId) return;
+  ledgers.delete(sessionId);
+}
+
 // src/tool-mapping.ts
 function mapToolInput(name, input) {
   if (!input) return input;
@@ -199,17 +284,42 @@ var CLAUDE_INTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "ToolSearch",
   "Agent",
   "AskFollowupQuestion",
-  "TaskCreate",
-  "TaskUpdate",
   "TaskList",
   "TaskGet",
   "TaskStop"
 ]);
+function emitTodoWrite(todos) {
+  return {
+    name: "todowrite",
+    input: {
+      todos: todos.map((todo) => ({
+        id: todo.id,
+        content: todo.content,
+        status: todo.status,
+        priority: "medium"
+      }))
+    },
+    executed: false
+  };
+}
 function mapTool(name, input, opts) {
   if (CLAUDE_INTERNAL_TOOLS.has(name)) {
     log.debug("skipping Claude CLI internal tool", { name });
     return { name, input, executed: true, skip: true };
   }
+  if (name === "TaskCreate") {
+    if (opts?.sessionId && opts?.toolUseId) {
+      applyTaskCreateToolUse(opts.sessionId, opts.toolUseId, input);
+    }
+    return { name, input, executed: true, skip: true };
+  }
+  if (name === "TaskUpdate") {
+    if (opts?.sessionId) {
+      const list = applyTaskUpdate(opts.sessionId, input);
+      if (list !== null) return emitTodoWrite(list);
+    }
+    return { name, input, executed: true, skip: true };
+  }
   if (name === "EnterPlanMode") return { name: "plan_enter", input: {}, executed: false };
   if (name === "ExitPlanMode") return { name: "plan_exit", input, executed: false };
   if (name === "TodoWrite") {
@@ -1181,6 +1291,8 @@ function setClaudeSessionId(key, sessionId) {
   claudeSessions.set(key, sessionId);
 }
 function deleteClaudeSessionId(key) {
+  const claudeSessionId = claudeSessions.get(key);
+  if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
 }
 function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile) {
@@ -1406,6 +1518,36 @@ var DEFAULT_PROXY_TOOLS = [
       },
       required: ["url"]
     }
+  },
+  {
+    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). The call blocks until the subagent finishes; the 10-minute proxy timeout applies.",
+    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"
+        }
+      },
+      required: ["description", "prompt", "subagent_type"]
+    }
   }
 ];
 async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
@@ -1642,7 +1784,8 @@ function disallowedToolFlags(tools) {
     edit: ["Edit", "MultiEdit"],
     glob: ["Glob"],
     grep: ["Grep"],
-    webfetch: ["WebFetch"]
+    webfetch: ["WebFetch"],
+    task: ["Agent"]
   };
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2672,7 +2815,11 @@ ${plan}
         input: mappedInput,
         executed,
         skip
-      } = mapTool(tc.name, tc.args, { webSearch: this.config.webSearch });
+      } = mapTool(tc.name, tc.args, {
+        webSearch: this.config.webSearch,
+        sessionId: getClaudeSessionId(sk),
+        toolUseId: tc.id
+      });
       if (skip) continue;
       content.push({
         type: "tool-call",
@@ -3115,7 +3262,11 @@ ${plan}
                     const { name: mappedName, skip, executed } = mapTool(
                       block.name,
                       void 0,
-                      { webSearch: self.config.webSearch }
+                      {
+                        webSearch: self.config.webSearch,
+                        sessionId: getClaudeSessionId(sk),
+                        toolUseId: block.id
+                      }
                     );
                     if (!skip) {
                       controller.enqueue({
@@ -3249,7 +3400,11 @@ ${plan}
                       input: mappedInput,
                       executed,
                       skip
-                    } = mapTool(tc.name, parsedInput, { webSearch: self.config.webSearch });
+                    } = mapTool(tc.name, parsedInput, {
+                      webSearch: self.config.webSearch,
+                      sessionId: getClaudeSessionId(sk),
+                      toolUseId: tc.id
+                    });
                     if (!skip) {
                       toolCallsById.set(tc.id, {
                         id: tc.id,
@@ -3415,7 +3570,11 @@ ${plan}
                         input: mappedInput,
                         executed,
                         skip
-                      } = mapTool(block.name, parsedInput, { webSearch: self.config.webSearch });
+                      } = mapTool(block.name, parsedInput, {
+                        webSearch: self.config.webSearch,
+                        sessionId: getClaudeSessionId(sk),
+                        toolUseId: block.id
+                      });
                       if (!skip) {
                         if (!executed) skipResultForIds.add(block.id);
                         controller.enqueue({
@@ -3456,16 +3615,48 @@ ${plan}
                       });
                       continue;
                     }
+                    let resultText = "";
+                    if (typeof block.content === "string") {
+                      resultText = block.content;
+                    } else if (Array.isArray(block.content)) {
+                      resultText = block.content.filter(
+                        (c) => c.type === "text" && typeof c.text === "string"
+                      ).map((c) => c.text).join("\n");
+                    }
+                    const claudeSessionId = getClaudeSessionId(sk);
+                    if (claudeSessionId) {
+                      const list = applyTaskCreateToolResult(
+                        claudeSessionId,
+                        block.tool_use_id,
+                        resultText
+                      );
+                      if (list) {
+                        const synthId = `todowrite_${block.tool_use_id}`;
+                        controller.enqueue({
+                          type: "tool-input-start",
+                          id: synthId,
+                          toolName: "todowrite",
+                          providerExecuted: false
+                        });
+                        controller.enqueue({
+                          type: "tool-call",
+                          toolCallId: synthId,
+                          toolName: "todowrite",
+                          input: JSON.stringify({
+                            todos: list.map((t) => ({
+                              id: t.id,
+                              content: t.content,
+                              status: t.status,
+                              priority: "medium"
+                            }))
+                          }),
+                          providerExecuted: false
+                        });
+                        noteToolActivity();
+                      }
+                    }
                     const toolCall = toolCallsById.get(block.tool_use_id);
                     if (toolCall) {
-                      let resultText = "";
-                      if (typeof block.content === "string") {
-                        resultText = block.content;
-                      } else if (Array.isArray(block.content)) {
-                        resultText = block.content.filter(
-                          (c) => c.type === "text" && typeof c.text === "string"
-                        ).map((c) => c.text).join("\n");
-                      }
                       controller.enqueue({
                         type: "tool-result",
                         toolCallId: block.tool_use_id,