@khalilgharbaoui/opencode-claude-code-plugin 0.4.3 → 0.4.5

package/README.md

@@ -171,6 +171,8 @@ The account model IDs are internally suffixed, for example `claude-sonnet-4-6@wo
 | `mcpConfig` | string \| string[] | – | Extra `--mcp-config` paths/JSON passed alongside the bridged config. |
 | `strictMcpConfig` | boolean | `false` | Pass `--strict-mcp-config` so Claude loads **only** the configured servers and ignores `~/.claude/settings.json`. |
 | `webSearch` | `"claude"` \| `"disabled"` \| `<tool>` | `"claude"` | Routing for Claude's built-in `WebSearch`. See [WebSearch routing](#websearch-routing). |
+| `multiStepContinuation` | boolean | `true` | Append a system-prompt hint nudging Claude to chain tool calls within one turn instead of pausing between subtasks. Each opencode turn boundary requires the user to manually press "continue", so for multi-step tasks this reduces friction. Set `false` to disable. |
+| `autoContinueIncompleteTurns` | boolean \| `"smart"` | `"smart"` | Smartly continue incomplete Claude CLI results inside the same opencode turn. Reduces manual "continue" presses when Claude ends after reasoning/tool activity without a useful final answer. Set `false` to disable. |
 
 ### Overriding model metadata
 
@@ -310,6 +312,7 @@ Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The
 ## Quirks worth knowing
 
 - **Empty text blocks are dropped.** Claude sometimes opens a `content_block_start` for text but never sends a delta. The plugin no longer emits the empty block (which was triggering Anthropic 400s like `cache_control cannot be set for empty text blocks`).
+- **Smart incomplete-turn continuation.** By default, the plugin keeps the current opencode stream open and feeds Claude CLI a small internal continuation message when Claude emits a `result` after reasoning/tool activity without a useful visible answer. It still stops normally on final-looking answers, questions, blockers, errors, aborts, or internal safety-budget exhaustion. Disable with `"autoContinueIncompleteTurns": false`.
 - **`AskUserQuestion`** from the CLI is converted into plain text content rather than forwarded as a tool call.
 - **Wire-inactivity watchdog.** Once the CLI has produced any content, the stream closes gracefully if stdout goes silent for 60 seconds without a `result` message arriving. Resets on every line received, so long mid-turn pauses (Sonnet between text-end and the next tool_use, for example) are tolerated. On a user-initiated abort, the watchdog shortens to 5 seconds.
 - **Per-iteration usage.** When the CLI internally retries with tools, the plugin only counts the last iteration's usage so opencode's context accounting stays accurate.

package/dist/index.d.ts

@@ -115,6 +115,8 @@ interface ClaudeCodeConfig {
     webSearch?: WebSearchRouting;
     hotReloadMcp?: boolean;
     proxyOpencodeMcpTools?: boolean;
+    multiStepContinuation?: boolean;
+    autoContinueIncompleteTurns?: boolean | "smart";
 }
 type WebSearchRouting = "claude" | "disabled" | (string & {});
 interface ClaudeCodeProviderSettings {
@@ -207,6 +209,30 @@ interface ClaudeCodeProviderSettings {
      * an opencode round-trip).
      */
     proxyOpencodeMcpTools?: boolean;
+    /**
+     * Append a short system-prompt hint that nudges Claude to chain
+     * multiple tool calls within a single turn instead of pausing for user
+     * confirmation between subtasks. Each turn boundary in opencode
+     * requires the user to manually press "continue" to resume, so for
+     * multi-step tasks this option reduces friction. Defaults to `true`.
+     *
+     * Set to `false` if you prefer the un-nudged model behavior (Claude
+     * decides when to end the turn entirely on its own).
+     */
+    multiStepContinuation?: boolean;
+    /**
+     * Smartly continue incomplete Claude CLI results inside the same opencode
+     * turn. Claude CLI sometimes emits `result` after reasoning/tool activity
+     * without a useful final answer, which makes opencode stop and wait for the
+     * user to type "continue". With the default `"smart"`, the plugin detects
+     * those incomplete result boundaries, feeds Claude a small continuation
+     * message internally, and keeps the opencode stream open. Final answers,
+     * questions, blockers, errors, aborts, and safety-budget exhaustion still
+     * stop normally.
+     *
+     * Set to `false` to disable.
+     */
+    autoContinueIncompleteTurns?: boolean | "smart";
 }
 type PermissionMode = "acceptEdits" | "auto" | "bypassPermissions" | "default" | "dontAsk" | "plan";
 type ControlRequestBehavior = "allow" | "deny";

package/dist/index.js

@@ -1483,6 +1483,77 @@ function hasNewUserContent(prompt) {
   }
   return false;
 }
+var AUTO_CONTINUE_MAX_ATTEMPTS = 8;
+var AUTO_CONTINUE_MAX_ELAPSED_MS = 10 * 60 * 1e3;
+var AUTO_CONTINUE_NO_PROGRESS_LIMIT = 2;
+var AUTO_CONTINUE_PROMPT = "Continue the task from where you stopped. Do not summarize; keep working until the requested task is complete, you need clarification, or you hit a real blocker.";
+function normalizeVisibleText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function looksLikeQuestion(text) {
+  const normalized = normalizeVisibleText(text).toLowerCase();
+  if (!normalized) return false;
+  if (normalized.endsWith("?")) return true;
+  return /\b(please confirm|can you confirm|should i|would you like|do you want|which option|choose|pick one|need your|need you to|what would you like)\b/.test(normalized);
+}
+function looksLikeBlocker(text) {
+  const normalized = normalizeVisibleText(text).toLowerCase();
+  if (!normalized) return false;
+  return /\b(blocked|blocker|cannot proceed|can't proceed|unable to proceed|need clarification|need more information|permission denied|failed and needs|requires your|manual step|required from you)\b/.test(normalized);
+}
+function looksLikeFinalAnswer(text) {
+  const normalized = normalizeVisibleText(text).toLowerCase();
+  if (normalized.length < 40) return false;
+  if (looksLikeQuestion(normalized) || looksLikeBlocker(normalized)) return false;
+  return /\b(done|completed|fixed|implemented|verified|published|released|sent|delivered|updated)\b/.test(normalized) || /\b(checks?|tests?) passed\b/.test(normalized) || /\b(summary|what changed|verification)\b/.test(normalized);
+}
+function continuationSignature(snapshot) {
+  const text = normalizeVisibleText(snapshot.text).slice(-500);
+  return JSON.stringify({
+    text,
+    reasoning: snapshot.hadReasoning,
+    tools: snapshot.hadToolActivity,
+    proxy: snapshot.hadProxyActivity
+  });
+}
+function shouldAutoContinueIncompleteTurn(state, snapshot) {
+  if (state.enabled === false) return { continue: false, reason: "disabled" };
+  if (snapshot.isError) return { continue: false, reason: "error" };
+  if (state.aborted) return { continue: false, reason: "aborted" };
+  if (state.attempts >= AUTO_CONTINUE_MAX_ATTEMPTS) {
+    return { continue: false, reason: "max-attempts" };
+  }
+  const now = snapshot.now ?? Date.now();
+  if (now - state.startedAt > AUTO_CONTINUE_MAX_ELAPSED_MS) {
+    return { continue: false, reason: "max-elapsed" };
+  }
+  const text = normalizeVisibleText(snapshot.text);
+  if (looksLikeQuestion(text)) return { continue: false, reason: "question" };
+  if (looksLikeBlocker(text)) return { continue: false, reason: "blocker" };
+  if (looksLikeFinalAnswer(text)) {
+    return { continue: false, reason: "final-answer" };
+  }
+  const hadActivity = snapshot.hadReasoning || snapshot.hadToolActivity || snapshot.hadProxyActivity;
+  if (!hadActivity) return { continue: false, reason: "no-activity" };
+  const signature = continuationSignature(snapshot);
+  const noProgress = signature === state.lastSignature;
+  if (noProgress && state.noProgressCount + 1 >= AUTO_CONTINUE_NO_PROGRESS_LIMIT) {
+    return { continue: false, reason: "no-progress" };
+  }
+  if (!text) {
+    return { continue: true, reason: "activity-without-visible-answer" };
+  }
+  return { continue: true, reason: "non-final-progress" };
+}
+function makeAutoContinueMessage() {
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [{ type: "text", text: AUTO_CONTINUE_PROMPT }]
+    }
+  });
+}
 function readPromptFileIfPresent(path5) {
   try {
     const content = readFileSync2(path5, "utf8").trim();
@@ -1501,13 +1572,22 @@ function nearestWorkspaceAgentsPrompt(cwd) {
     dir = parent;
   }
 }
-function buildAppendedSystemPrompt(cwd) {
+var MULTI_STEP_TASK_HINT = `## Continuing through multi-step tasks
+
+opencode requires the user to press "continue" after each turn ends. When a
+task has multiple steps, do them all in one turn \u2014 chain tool calls rather
+than pausing for user confirmation between subtasks. End the turn only
+when the task is done, you need clarification on intent, or you hit a real
+blocker. The user can interrupt or abort at any time; turn endings should
+mark meaningful checkpoints, not every completed substep.`;
+function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true) {
   const parts = [];
   const configRoot = process.env.XDG_CONFIG_HOME ?? join4(homedir2(), ".config");
   const globalAgents = readPromptFileIfPresent(join4(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   if (globalAgents) parts.push(globalAgents);
   if (workspaceAgents && workspaceAgents !== globalAgents) parts.push(workspaceAgents);
+  if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
   const path5 = join4(tmpdir2(), `opencode-cc-sys-${randomUUID2()}.md`);
@@ -1981,7 +2061,10 @@ var ClaudeCodeLanguageModel = class {
       reasoningEffort
     );
     const runtimeStatus = await getRuntimeMcpStatus();
-    const systemPromptFile = buildAppendedSystemPrompt(cwd);
+    const systemPromptFile = buildAppendedSystemPrompt(
+      cwd,
+      this.config.multiStepContinuation !== false
+    );
     const cliArgs = buildCliArgs({
       sessionKey: sk,
       skipPermissions: this.config.skipPermissions !== false,
@@ -2351,7 +2434,10 @@ ${plan}
             runtimeStatus,
             excludeServers
           );
-          const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(cwd);
+          const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(
+            cwd,
+            self.config.multiStepContinuation !== false
+          );
           const cliArgs = buildCliArgs({
             sessionKey: sk,
             skipPermissions,
@@ -2405,6 +2491,16 @@ ${plan}
           let pendingProxyUnsubscribe = null;
           let resultFallbackTimer = null;
           let hasReceivedContent = false;
+          let visibleTextSinceContinue = "";
+          let hadReasoningSinceContinue = false;
+          let hadToolActivitySinceContinue = false;
+          let hadProxyActivitySinceContinue = false;
+          const autoContinueState = {
+            enabled: self.config.autoContinueIncompleteTurns,
+            attempts: 0,
+            startedAt: Date.now(),
+            noProgressCount: 0
+          };
           const clearFallbackTimer = () => {
             if (resultFallbackTimer) {
               clearTimeout(resultFallbackTimer);
@@ -2477,6 +2573,24 @@ ${plan}
             });
             finishWithToolCalls(batch);
           };
+          const noteVisibleText = (text) => {
+            visibleTextSinceContinue += text;
+          };
+          const noteReasoning = () => {
+            hadReasoningSinceContinue = true;
+          };
+          const noteToolActivity = () => {
+            hadToolActivitySinceContinue = true;
+          };
+          const noteProxyActivity = () => {
+            hadProxyActivitySinceContinue = true;
+          };
+          const resetAutoContinueWindow = () => {
+            visibleTextSinceContinue = "";
+            hadReasoningSinceContinue = false;
+            hadToolActivitySinceContinue = false;
+            hadProxyActivitySinceContinue = false;
+          };
           let gotPartialEvents = false;
           const lineHandler = (line) => {
             if (!line.trim()) return;
@@ -2507,6 +2621,7 @@ ${plan}
                 const block = msg.content_block;
                 const idx = msg.index;
                 if (block.type === "thinking") {
+                  noteReasoning();
                   const reasoningId = generateId();
                   reasoningIds.set(idx, reasoningId);
                   controller.enqueue({
@@ -2524,10 +2639,12 @@ ${plan}
                       id: currentTextId,
                       delta: block.text
                     });
+                    noteVisibleText(block.text);
                     hasReceivedContent = true;
                   }
                 }
                 if (block.type === "tool_use" && block.id && block.name) {
+                  noteToolActivity();
                   toolCallMap.set(idx, {
                     id: block.id,
                     name: block.name,
@@ -2559,6 +2676,7 @@ ${plan}
                 const delta = msg.delta;
                 const idx = msg.index;
                 if (delta.type === "thinking_delta" && delta.thinking) {
+                  noteReasoning();
                   const reasoningId = reasoningIds.get(idx);
                   if (reasoningId) {
                     controller.enqueue({
@@ -2575,6 +2693,7 @@ ${plan}
                     id: currentTextId,
                     delta: delta.text
                   });
+                  noteVisibleText(delta.text);
                   hasReceivedContent = true;
                 }
                 if (delta.type === "input_json_delta" && delta.partial_json) {
@@ -2704,9 +2823,11 @@ ${plan}
                       delta: block.text
                     });
                     endTextBlock();
+                    noteVisibleText(block.text);
                     hasReceivedContent = true;
                   }
                   if (block.type === "thinking" && block.thinking) {
+                    noteReasoning();
                     const thinkingId = generateId();
                     controller.enqueue({
                       type: "reasoning-start",
@@ -2723,6 +2844,7 @@ ${plan}
                     });
                   }
                   if (block.type === "tool_use" && block.id && block.name) {
+                    noteToolActivity();
                     const parsedInput = block.input ?? {};
                     toolCallsById.set(block.id, {
                       id: block.id,
@@ -2836,6 +2958,7 @@ ${plan}
                         },
                         providerExecuted: true
                       });
+                      noteToolActivity();
                       log.info("tool result emitted", {
                         toolUseId: block.tool_use_id,
                         name: toolCall.name
@@ -2899,6 +3022,46 @@ ${plan}
                     )
                   );
                 }
+                const autoDecision = shouldAutoContinueIncompleteTurn(
+                  autoContinueState,
+                  {
+                    text: visibleTextSinceContinue,
+                    hadReasoning: hadReasoningSinceContinue,
+                    hadToolActivity: hadToolActivitySinceContinue,
+                    hadProxyActivity: hadProxyActivitySinceContinue,
+                    isError: msg.is_error
+                  }
+                );
+                if (autoDecision.continue) {
+                  const signature = continuationSignature({
+                    text: visibleTextSinceContinue,
+                    hadReasoning: hadReasoningSinceContinue,
+                    hadToolActivity: hadToolActivitySinceContinue,
+                    hadProxyActivity: hadProxyActivitySinceContinue,
+                    isError: msg.is_error
+                  });
+                  autoContinueState.noProgressCount = signature === autoContinueState.lastSignature ? autoContinueState.noProgressCount + 1 : 0;
+                  autoContinueState.lastSignature = signature;
+                  autoContinueState.attempts++;
+                  log.info("auto-continuing incomplete claude result", {
+                    sessionKey: sk,
+                    reason: autoDecision.reason,
+                    attempts: autoContinueState.attempts,
+                    textLength: visibleTextSinceContinue.length,
+                    hadReasoning: hadReasoningSinceContinue,
+                    hadToolActivity: hadToolActivitySinceContinue,
+                    hadProxyActivity: hadProxyActivitySinceContinue
+                  });
+                  turnCompleted = false;
+                  resetAutoContinueWindow();
+                  proc.stdin?.write(makeAutoContinueMessage() + "\n");
+                  return;
+                }
+                log.info("auto-continuation stopped", {
+                  sessionKey: sk,
+                  reason: autoDecision.reason,
+                  attempts: autoContinueState.attempts
+                });
                 for (const [idx, reasoningId] of reasoningIds) {
                   if (reasoningStarted.get(idx)) {
                     controller.enqueue({
@@ -3021,6 +3184,8 @@ ${plan}
               toolCallId: call.toolCallId,
               toolName: call.toolName
             });
+            noteProxyActivity();
+            noteToolActivity();
             drainBuffer.push(call);
             if (drainTimer) clearTimeout(drainTimer);
             drainTimer = setTimeout(drainNow, DRAIN_QUIET_MS);
@@ -3028,6 +3193,7 @@ ${plan}
           proc.on("error", procErrorHandler);
           if (options.abortSignal) {
             options.abortSignal.addEventListener("abort", () => {
+              autoContinueState.aborted = true;
               if (turnCompleted || controllerClosed) return;
               if (!hasReceivedContent) {
                 log.info(
@@ -3540,7 +3706,9 @@ function createClaudeCode(settings = {}) {
       proxyTools,
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
-      proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true
+      proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,
+      multiStepContinuation: settings.multiStepContinuation ?? true,
+      autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart"
     });
   };
   const provider = function(modelId) {