@khalilgharbaoui/opencode-claude-code-plugin 0.12.0 → 0.12.1

package/README.md

@@ -183,6 +183,7 @@ The account model IDs are internally suffixed, for example `claude-sonnet-4-6@wo
 | `permissionMode` | `acceptEdits` \| `auto` \| `bypassPermissions` \| `default` \| `dontAsk` \| `plan` | – | Forwarded to `claude --permission-mode`. |
 | `proxyTools` | string[] | `["Bash", "Edit", "Write", "WebFetch", "Task"]` | Claude built-in tools to route through opencode's executor + permission UI. See [Selective tool proxy](#selective-tool-proxy). |
 | `proxyToolTimeoutMs` | `Record<string, number>` | – | Per-tool proxy call deadline in ms, keyed by proxy tool name (`bash`, `task`, …). Defaults: 10 min flat, `task` → 60 min. For `bash`, the call's own `input.timeout` is honoured on top (`max(resolved, input.timeout)`). See [Selective tool proxy](#selective-tool-proxy). |
+| `planModeQuestion` | boolean | `false` | Route `ExitPlanMode` approval through opencode's native `question` tool instead of a text "(yes/no)" prompt. Off because opencode's question form is currently broken upstream. See [Plan mode](#plan-mode). |
 | `controlRequestBehavior` | `allow` \| `deny` | `allow` | Default response when `skipPermissions: false` and Claude sends a `can_use_tool` control request. |
 | `controlRequestToolBehaviors` | `Record<string, "allow" \| "deny">` | – | Per-tool override for `can_use_tool`. Example: `{ "Bash": "deny", "Read": "allow" }`. |
 | `controlRequestDenyMessage` | string | built-in message | Message returned to Claude on a deny. |
@@ -450,6 +451,25 @@ Each chat keeps a long-lived `claude` subprocess so the model retains its native
 
 Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The plugin handles `ExitPlanMode` specially — instead of forwarding it as a tool call, it converts it to a confirmation prompt that flows through opencode normally.
 
+By default that prompt is text: the plan is rendered as markdown, followed by `**Do you want to proceed with this plan?** (yes/no)`, and you answer in your next message.
+
+### Approval as a real form (`planModeQuestion`, opt-in)
+
+Set `planModeQuestion: true` to route the approval through opencode's native `question` tool instead:
+
+```json
+"options": {
+  "permissionMode": "plan",
+  "planModeQuestion": true
+}
+```
+
+The plan is still rendered, but the turn then ends on `tool-calls` and opencode runs its own `question` tool, so approval is a form rather than prose. Your answer is fed back to the CLI as the `tool_result` for the original `ExitPlanMode` call, which is what actually unlocks plan mode on the Claude side. A "yes" typed as ordinary text never does that. Anything other than picking `yes` (including custom text) comes back as rejection feedback the model is told to act on.
+
+> **Leave this off for now.** It depends on the same opencode `question` form that is [broken upstream](#with-question-in-proxytools-currently-blocked-upstream--leave-it-off): with it on, a plan approval hangs until you interrupt the turn. On opencode builds with no `question` registry entry at all the plugin silently keeps the text path (look for `plan-mode question gate` in the log). Re-test when [anomalyco/opencode#36603](https://github.com/anomalyco/opencode/pull/36603) merges.
+
+Approval bridge contributed by [@CollieIsCute](https://github.com/CollieIsCute).
+
 ---
 
 ## AskUserQuestion

package/dist/index.d.ts

@@ -162,6 +162,14 @@ interface ClaudeCodeConfig {
     controlRequestDenyMessage?: string;
     proxyTools?: string[];
     proxyToolTimeoutMs?: Record<string, number>;
+    /**
+     * Route `ExitPlanMode` through opencode's native `question` tool so plan
+     * approval is a real form instead of a "(yes/no)" line the operator has to
+     * answer in prose. Off by default: opencode's question form is currently
+     * broken upstream, so enabling this trades a working text prompt for a
+     * silent hang. See the plan-mode gotcha in AGENTS.md.
+     */
+    planModeQuestion?: boolean;
     webSearch?: WebSearchRouting;
     hotReloadMcp?: boolean;
     proxyOpencodeMcpTools?: boolean;
@@ -292,6 +300,23 @@ interface ClaudeCodeProviderSettings {
      * long build the caller explicitly asked to run is never undercut.
      */
     proxyToolTimeoutMs?: Record<string, number>;
+    /**
+     * Route Claude's `ExitPlanMode` through opencode's native `question` tool.
+     *
+     * Off (default): the plan is rendered as markdown followed by
+     * `**Do you want to proceed with this plan?** (yes/no)` and the operator
+     * answers in prose. On: the plan is rendered, the turn ends on
+     * `tool-calls`, and opencode runs its own `question` tool so approval is a
+     * real form; the answer is fed back to the CLI as the `tool_result` for
+     * the original `ExitPlanMode` call, which is what unlocks plan mode.
+     *
+     * Two reasons it is opt-in. opencode's `question` form does not currently
+     * render (upstream anomalyco/opencode#36604), so an enabled bridge hangs
+     * the turn until the operator interrupts; and older opencode builds have
+     * no `question` registry entry at all, in which case the plugin silently
+     * keeps the text path. See the plan-mode gotcha in AGENTS.md.
+     */
+    planModeQuestion?: boolean;
     /**
      * Strip `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` from the environment of
      * every spawned `claude` process. When an API key is present, Claude Code
@@ -525,9 +550,20 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      *   call resolves to `⚙ invalid`; the version gate drops the def.
      *
      * Returns undefined/false when the SDK client is unavailable (direct
-     * AI-SDK use, tests) so the static defs stand.
+     * AI-SDK use, tests) so the static defs stand. `resolved` distinguishes
+     * "the registry answered and has no `question` entry" from "nobody
+     * answered": only the former is a real version-gate signal.
      */
     private fetchLiveToolInfo;
+    /** Share one lazy registry request within a turn without making it stale. */
+    private createLiveToolInfoLoader;
+    /**
+     * Whether the ExitPlanMode approval bridge is live for this turn: the
+     * operator opted in AND opencode's registry actually has the `question`
+     * tool. Without the registry entry the emitted tool-call would render as
+     * `⚙ invalid` and wedge the turn, so the plugin keeps the text path.
+     */
+    private resolvePlanModeQuestion;
     /**
      * Create a proxy MCP server for a single active Claude process/session.
      * The process lifecycle owns the server lifecycle via session-manager.

package/dist/index.js

@@ -393,7 +393,7 @@ var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
   "image/webp"
 ]);
 function toImageBlock(part) {
-  const raw = part.data ?? part.url ?? part.source?.data;
+  const raw = part.image ?? part.data ?? part.url ?? part.source?.data;
   if (!raw) {
     log.warn("file part without data, skipping");
     return null;
@@ -728,6 +728,161 @@ Now continuing with the current message:
   });
 }
 
+// src/plan-mode-question.ts
+var QUESTION_TOOL_NAME = "question";
+var APPROVED_EXIT_PLAN_MODE_MESSAGE = "User has approved your plan. You can now start coding. Start with updating your todo list if applicable.";
+var REJECTED_EXIT_PLAN_MODE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected. To tell you how to proceed, the user said:";
+var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
+var OPENCODE_QUESTION_RESULT_PREFIX = `User has answered your questions: "${PLAN_MODE_APPROVAL_QUESTION}"="`;
+var OPENCODE_QUESTION_RESULT_SUFFIX = `". You can now continue with the user's answers in mind.`;
+var KEY_SEPARATOR = "\0";
+function isPlanModeQuestionActive(input) {
+  if (input.compactionMode) return false;
+  if (input.configured !== true) return false;
+  return input.opencodeHasQuestion;
+}
+var pendingQuestions = /* @__PURE__ */ new Map();
+function pendingKey(sessionKey2, questionToolCallId) {
+  return `${sessionKey2}${KEY_SEPARATOR}${questionToolCallId}`;
+}
+function clearExitPlanModeQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
+  for (const key of pendingQuestions.keys()) {
+    if (key.startsWith(prefix)) pendingQuestions.delete(key);
+  }
+}
+function createExitPlanModeQuestionCall(sessionKey2, exitPlanModeToolUseId, plan, questionToolCallId = `exit_plan_question_${exitPlanModeToolUseId}`) {
+  pendingQuestions.set(pendingKey(sessionKey2, questionToolCallId), exitPlanModeToolUseId);
+  return {
+    toolCallId: questionToolCallId,
+    toolName: QUESTION_TOOL_NAME,
+    input: {
+      questions: [
+        {
+          header: "Plan approval",
+          question: PLAN_MODE_APPROVAL_QUESTION,
+          options: [
+            { label: "yes", description: "" },
+            { label: "no", description: "" }
+          ],
+          multiple: false,
+          custom: true
+        }
+      ]
+    },
+    text: plan ? `
+
+${plan}
+` : "\n\n"
+  };
+}
+function buildToolResultMessage(input) {
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [
+        input.approved ? {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: APPROVED_EXIT_PLAN_MODE_MESSAGE
+        } : {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: `${REJECTED_EXIT_PLAN_MODE_PREFIX}
+${input.feedback || "no"}`,
+          is_error: true
+        }
+      ]
+    }
+  });
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapToolOutput(part) {
+  const output = part?.output ?? part?.result;
+  if (typeof output === "string") return tryParseJson(output);
+  if (!output || typeof output !== "object") return output;
+  switch (output.type) {
+    case "json":
+    case "error-json":
+      return output.value;
+    case "text":
+    case "error-text":
+      return tryParseJson(String(output.value ?? ""));
+    case "execution-denied":
+      return {
+        denied: true,
+        reason: String(output.reason ?? "question rejected")
+      };
+    case "content":
+      return Array.isArray(output.value) ? output.value.map((item) => {
+        if (item?.type === "text") return item.text;
+        return JSON.stringify(item);
+      }).join("\n") : output.value;
+    default:
+      return output;
+  }
+}
+function unwrapOpencodeQuestionResult(value) {
+  if (value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) && value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
+    return value.slice(
+      OPENCODE_QUESTION_RESULT_PREFIX.length,
+      -OPENCODE_QUESTION_RESULT_SUFFIX.length
+    );
+  }
+  return value;
+}
+function collectAnswerStrings(value) {
+  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value)];
+  if (Array.isArray(value)) return value.flatMap(collectAnswerStrings);
+  if (!value || typeof value !== "object") return [];
+  const obj = value;
+  if (obj.denied === true) return [String(obj.reason ?? "question rejected")];
+  for (const key of ["answers", "answer", "selected", "selection", "value"]) {
+    if (key in obj) return collectAnswerStrings(obj[key]);
+  }
+  return [];
+}
+function classifyQuestionResult(part) {
+  const output = unwrapToolOutput(part);
+  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  if (answers.length === 1 && answers[0].toLowerCase() === "yes") {
+    return { approved: true, feedback: "" };
+  }
+  return {
+    approved: false,
+    feedback: answers.length > 0 ? answers.join("\n") : "no"
+  };
+}
+function consumeExitPlanModeQuestionResult(sessionKey2, prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part?.type !== "tool-result" || typeof part.toolCallId !== "string") {
+        continue;
+      }
+      const key = pendingKey(sessionKey2, part.toolCallId);
+      const exitPlanModeToolUseId = pendingQuestions.get(key);
+      if (!exitPlanModeToolUseId) continue;
+      pendingQuestions.delete(key);
+      const result = classifyQuestionResult(part);
+      return buildToolResultMessage({
+        toolUseId: exitPlanModeToolUseId,
+        approved: result.approved,
+        feedback: result.feedback
+      });
+    }
+  }
+  return null;
+}
+
 // src/mcp-bridge.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -1341,6 +1496,7 @@ function setClaudeSessionId(key, sessionId) {
   claudeSessions.set(key, sessionId);
 }
 function deleteClaudeSessionId(key) {
+  clearExitPlanModeQuestions(key);
   const claudeSessionId = claudeSessions.get(key);
   if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
@@ -3182,7 +3338,9 @@ var ClaudeCodeLanguageModel = class {
    *   call resolves to `⚙ invalid`; the version gate drops the def.
    *
    * Returns undefined/false when the SDK client is unavailable (direct
-   * AI-SDK use, tests) so the static defs stand.
+   * AI-SDK use, tests) so the static defs stand. `resolved` distinguishes
+   * "the registry answered and has no `question` entry" from "nobody
+   * answered": only the former is a real version-gate signal.
    */
   async fetchLiveToolInfo() {
     const items = await fetchOpencodeToolList(
@@ -3192,11 +3350,43 @@ var ClaudeCodeLanguageModel = class {
     );
     const question = items?.find((item) => item.id === "question");
     return {
+      resolved: items !== void 0,
       taskDescription: items?.find((item) => item.id === "task")?.description,
       questionDescription: question?.description,
       hasQuestion: !!question
     };
   }
+  /** Share one lazy registry request within a turn without making it stale. */
+  createLiveToolInfoLoader() {
+    let pending;
+    return () => {
+      pending ??= this.fetchLiveToolInfo();
+      return pending;
+    };
+  }
+  /**
+   * Whether the ExitPlanMode approval bridge is live for this turn: the
+   * operator opted in AND opencode's registry actually has the `question`
+   * tool. Without the registry entry the emitted tool-call would render as
+   * `⚙ invalid` and wedge the turn, so the plugin keeps the text path.
+   */
+  async resolvePlanModeQuestion(compactionMode, loadLiveToolInfo = () => this.fetchLiveToolInfo()) {
+    if (compactionMode || this.config.planModeQuestion !== true) return false;
+    const info = await loadLiveToolInfo();
+    const active = isPlanModeQuestionActive({
+      configured: this.config.planModeQuestion,
+      opencodeHasQuestion: info.hasQuestion,
+      compactionMode
+    });
+    if (!active) {
+      log.info("plan-mode question gate", {
+        opencodeHasQuestion: info.hasQuestion,
+        registryResolved: info.resolved,
+        active
+      });
+    }
+    return active;
+  }
   /**
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
@@ -3569,14 +3759,11 @@ var ClaudeCodeLanguageModel = class {
     const hasExistingSession = !!getClaudeSessionId(sk);
     const includeHistoryContext = !hasExistingSession && hasPriorConversation;
     const reasoningEffort = this.getReasoningEffort(options.providerOptions);
-    const userMsg = getClaudeUserMessage(
-      options.prompt,
-      includeHistoryContext,
-      reasoningEffort
-    );
-    const [runtimeStatus, cliVersion] = await Promise.all([
+    const userMsg = consumeExitPlanModeQuestionResult(sk, options.prompt) ?? getClaudeUserMessage(options.prompt, includeHistoryContext, reasoningEffort);
+    const [runtimeStatus, cliVersion, planModeQuestionActive] = await Promise.all([
       getRuntimeMcpStatus(),
-      detectCliVersion(this.config.cliPath)
+      detectCliVersion(this.config.cliPath),
+      this.resolvePlanModeQuestion(compactionMode)
     ]);
     const systemPromptFile = buildAppendedSystemPrompt(
       cwd,
@@ -3665,6 +3852,20 @@ var ClaudeCodeLanguageModel = class {
                 if (block.name === "ExitPlanMode") {
                   const parsedInput = block.input ?? {};
                   const plan = parsedInput?.plan || "";
+                  if (planModeQuestionActive) {
+                    const questionCall = createExitPlanModeQuestionCall(
+                      sk,
+                      block.id,
+                      plan
+                    );
+                    responseText += questionCall.text;
+                    toolCalls.push({
+                      id: questionCall.toolCallId,
+                      name: questionCall.toolName,
+                      args: questionCall.input
+                    });
+                    continue;
+                  }
                   responseText += `
 
 ${plan}
@@ -3715,7 +3916,19 @@ ${plan}
                   error: String(err)
                 });
               }
-              toolCalls.push({ id: tc.id, name: tc.name, args });
+              if (tc.name === "ExitPlanMode" && planModeQuestionActive) {
+                const parsedInput = args;
+                const plan = parsedInput?.plan || "";
+                const questionCall = createExitPlanModeQuestionCall(sk, tc.id, plan);
+                responseText += questionCall.text;
+                toolCalls.push({
+                  id: questionCall.toolCallId,
+                  name: questionCall.toolName,
+                  args: questionCall.input
+                });
+              } else {
+                toolCalls.push({ id: tc.id, name: tc.name, args });
+              }
               toolCallStreams.delete(msg.index);
             }
           }
@@ -3788,6 +4001,16 @@ ${plan}
       });
     }
     for (const tc of result.toolCalls) {
+      if (tc.name === QUESTION_TOOL_NAME) {
+        content.push({
+          type: "tool-call",
+          toolCallId: tc.id,
+          toolName: tc.name,
+          input: JSON.stringify(tc.args),
+          providerExecuted: false
+        });
+        continue;
+      }
       const {
         name: mappedName,
         input: mappedInput,
@@ -3810,11 +4033,13 @@ ${plan}
     const usage = this.toUsage(result.usage);
     return {
       content,
-      // Claude CLI's `result` message signals a fully-completed turn —
-      // tools have already been executed internally and final assistant
-      // text has been produced. Always report "stop" so opencode doesn't
-      // loop expecting to run tools itself.
-      finishReason: this.toFinishReason("stop"),
+      // Claude CLI's `result` message normally signals a fully-completed turn:
+      // tools have already been executed internally and final assistant text
+      // has been produced. ExitPlanMode is the exception: we surface it as
+      // opencode's native question tool so the outer loop must run that tool.
+      finishReason: this.toFinishReason(
+        result.toolCalls.some((tc) => tc.name === QUESTION_TOOL_NAME) ? "tool-calls" : "stop"
+      ),
       usage,
       request: { body: { text: userMsg } },
       response: {
@@ -3918,13 +4143,19 @@ ${plan}
     const hasActiveProcess = !!getActiveProcess(sk);
     const includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
     const reasoningEffort = this.getReasoningEffort(options.providerOptions);
-    const userMsg = getClaudeUserMessage(
-      options.prompt,
-      includeHistoryContext,
-      reasoningEffort,
-      { compactionMode }
-    );
+    const exitPlanModeQuestionResult = compactionMode ? null : consumeExitPlanModeQuestionResult(sk, options.prompt);
+    if (exitPlanModeQuestionResult) {
+      log.info("sending plan approval decision to claude", { sk });
+    }
+    const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(options.prompt, includeHistoryContext, reasoningEffort, {
+      compactionMode
+    });
     const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
+    const loadLiveToolInfo = this.createLiveToolInfoLoader();
+    const planModeQuestionActive = await this.resolvePlanModeQuestion(
+      compactionMode,
+      loadLiveToolInfo
+    );
     const self = this;
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
     const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
@@ -4070,7 +4301,8 @@ ${plan}
               const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
               const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
               const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
-              const liveToolInfo = taskProxyEnabled || questionProxyEnabled ? await self.fetchLiveToolInfo() : {
+              const liveToolInfo = taskProxyEnabled || questionProxyEnabled ? await loadLiveToolInfo() : {
+                resolved: false,
                 taskDescription: void 0,
                 questionDescription: void 0,
                 hasQuestion: false
@@ -4362,6 +4594,37 @@ ${plan}
             } catch {
             }
           };
+          const finishWithExitPlanQuestion = (call) => {
+            if (controllerClosed) return;
+            endTextBlock();
+            controller.enqueue({
+              type: "tool-input-start",
+              id: call.toolCallId,
+              toolName: call.toolName,
+              providerExecuted: false
+            });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: call.toolCallId,
+              toolName: call.toolName,
+              input: JSON.stringify(call.input),
+              providerExecuted: false
+            });
+            controller.enqueue({
+              type: "finish",
+              finishReason: toFinishReason("tool-calls"),
+              usage: toUsage(resultMeta.usage),
+              providerMetadata: {
+                "claude-code": resultMeta
+              }
+            });
+            controllerClosed = true;
+            cleanupTurn();
+            try {
+              controller.close();
+            } catch {
+            }
+          };
           const drainNow = () => {
             if (drainTimer) {
               clearTimeout(drainTimer);
@@ -4687,6 +4950,21 @@ ${plan}
                     endTextBlock();
                   } else if (tc.name === "ExitPlanMode") {
                     const plan = parsedInput?.plan || "";
+                    if (planModeQuestionActive) {
+                      const questionCall = createExitPlanModeQuestionCall(
+                        sk,
+                        tc.id,
+                        plan
+                      );
+                      const planId2 = startTextBlock();
+                      controller.enqueue({
+                        type: "text-delta",
+                        id: planId2,
+                        delta: questionCall.text
+                      });
+                      finishWithExitPlanQuestion(questionCall);
+                      return;
+                    }
                     const planId = startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
@@ -4853,6 +5131,21 @@ ${plan}
                       endTextBlock();
                     } else if (block.name === "ExitPlanMode") {
                       const plan = parsedInput?.plan || "";
+                      if (planModeQuestionActive) {
+                        const questionCall = createExitPlanModeQuestionCall(
+                          sk,
+                          block.id,
+                          plan
+                        );
+                        const planId2 = startTextBlock();
+                        controller.enqueue({
+                          type: "text-delta",
+                          id: planId2,
+                          delta: questionCall.text
+                        });
+                        finishWithExitPlanQuestion(questionCall);
+                        return;
+                      }
                       const planId = startTextBlock();
                       controller.enqueue({
                         type: "text-delta",
@@ -5818,6 +6111,7 @@ function collectStartupDiagnostics(providers, opencodeVersion) {
     proxyTools: stringList(firstOption(providers, "proxyTools")),
     mcpServers,
     interactiveTransport: firstOption(providers, "interactive") === true || process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT === "1",
+    planModeQuestion: firstOption(providers, "planModeQuestion") === true,
     anthropicApiKeyInEnv: Boolean(
       process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN
     )
@@ -5906,6 +6200,7 @@ function createClaudeCode(settings = {}) {
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
+      planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,