opencode-auto-resume 1.1.16 → 1.1.18

package/README.md

@@ -46,6 +46,20 @@ A separate **tool-call loop detector** catches the model calling the same tool 3
 
 Loop detection runs in two places. At idle, tool names are scanned from recent assistant messages. **Live**, every `tool.execute.before` hook fingerprints the call as `tool name + arguments` — so a subagent stuck re-reading the same file/range (even alternating between two near-identical argument sets, which never produces 3 consecutive identical calls) is caught after 6+ calls in the repeating cycle. On live detection the plugin aborts the running turn immediately (this is the sanctioned exception to the never-abort-busy rule: 6+ identical name+args fingerprints prove a hallucinated loop, and the current call has not started yet) and then sends `TOOL_LOOP_RECOVERY_PROMPT`. Esc-cancelled sessions are never touched.
 
+---
+
+### Unknown tool suggestion
+
+When the model calls a tool that does not exist (a typo, a hallucinated name, or a tool from a different plugin that isn't loaded), OpenCode returns a `tool` part with `state.status = "error"`. If the same wrong tool name appears **2 times** in the session's message history, the plugin:
+
+1. Fetches the list of available tools via `ctx.client.tool.ids()` (cached for 5 minutes).
+2. Computes the closest match by Levenshtein distance (case-insensitive, threshold = half the wrong name's length).
+3. Sends a continue prompt that names the wrong tool, states it does not exist, suggests the closest match (if one was found), and lists the first 20 available tools for reference.
+
+The suggestion fires once per busy cycle. A new user message resets the counter so the suggestion can fire again on a fresh cycle. Tool parts that already succeeded (`state.status = "completed"`) and parts for tools that do exist are skipped.
+
+Threshold and cache are compile-time constants (`UNKNOWN_TOOL_THRESHOLD = 2`, `TOOL_IDS_CACHE_MS = 5 min`). The detection runs at idle, alongside the tool-text recovery check.
+
 _Motivated by:_
 - [#22142](https://github.com/anomalyco/opencode/issues/22142) — Repetitive tool-call loops with alibaba-coding-plan-cn/qwen3.6-plus
 - [#16218](https://github.com/anomalyco/opencode/issues/16218) — Model repeats the same response in a loop after generating an answer
@@ -203,6 +217,8 @@ The agent can call the built-in `task_complete` tool to signal that all work is
 
 If `task_complete` is called while open todos remain, the call is rejected (up to `maxRetries` times) with a message asking the agent to finish the remaining work first.
 
+Repeat calls with no new user message in between are guarded: the first acknowledgement carries an explicit stop instruction, the second returns a repeat warning, and the third and subsequent calls are rejected as errors. This breaks the ack self-loop where the acknowledgement tool-result is fed back into the turn and a stuck model re-emits `task_complete` instead of ending with text. The counter resets on a genuine user message, on the block path above, or when any other tool runs in between.
+
 ---
 
 ### 🎉 emoji completion
@@ -312,6 +328,10 @@ session.status events:
 
 todo.updated events:
   └─ track real todo state (not regex on message text)
+     └─ if missing (no event received): idle path + task_complete
+        fetch on-demand via session.todo() API so the
+        open-todos reminder and the 🎉 completion latch see
+        real state, not a stale empty array.
 
 Timer loop (every 5s):
   for each busy session:

package/dist/index.js

@@ -12363,7 +12363,8 @@ var DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS = [
   "streaming response failed",
   "stream.*fail",
   "connection.*reset",
-  "connection.*closed"
+  "connection.*closed",
+  "aborted due to timeout"
 ];
 var MAX_IDLE_SESSIONS = 50;
 var IDLE_CLEANUP_MS = 10 * 60000;
@@ -12371,7 +12372,12 @@ var SESSION_DISCOVERY_INTERVAL_MS = 60000;
 var TOOL_TEXT_RECOVERY_PROMPT = "Your last message contained a raw tool call printed as text instead of being executed. " + "Please use the proper tool calling mechanism to execute it.";
 var THINKING_TOOL_RECOVERY_PROMPT = "I noticed you have a tool call generated in your thinking/reasoning. " + "Please execute it using the proper tool calling mechanism instead of keeping it in reasoning.";
 var TOOL_LOOP_RECOVERY_PROMPT = "I notice you've been calling the same tool multiple times in a row without making progress. " + "Please step back and reassess your approach. Consider: " + "1) Are you stuck in a loop? 2) Do you need different information first? " + "3) Should you try a different tool or break the task into smaller steps? " + "Take a moment to think about what's blocking you and propose a different strategy.";
+var TASK_COMPLETE_ACK = "Task completion acknowledged. No further continuation will be sent. " + "End your turn now with a brief text reply \u2014 do not call task_complete or any other tool again " + "unless the user sends a new message.";
+var TASK_COMPLETE_REPEAT_WARNING = "Task completion acknowledged already on your previous call \u2014 completion is recorded. " + "End your turn now with a brief text reply. Do not call task_complete again; " + "further repeat calls are rejected as errors.";
+var TASK_COMPLETE_REPEAT_ERROR = "task_complete already acknowledged twice with no new user message or tool work since \u2014 " + "completion is recorded. End your turn with text and make no further tool calls.";
 var CTX_WRAPUP_TRIGGER = "ctx-wrapup";
+var UNKNOWN_TOOL_THRESHOLD = 2;
+var TOOL_IDS_CACHE_MS = 5 * 60000;
 var TOOL_TEXT_PATTERNS = [
   /<function\s*=/i,
   /<function>/i,
@@ -12466,6 +12472,42 @@ function containsWorkDescription(text) {
     return true;
   return false;
 }
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  if (m === 0)
+    return n;
+  if (n === 0)
+    return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0;j <= n; j++)
+    prev[j] = j;
+  for (let i = 1;i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    const tmp = prev;
+    prev = curr;
+    curr = tmp;
+  }
+  return prev[n];
+}
+function suggestClosestTool(wrongName, available) {
+  const lower = wrongName.toLowerCase();
+  let best = null;
+  let bestDist = Infinity;
+  for (const id of available) {
+    const dist = levenshtein(lower, id.toLowerCase());
+    const threshold = Math.max(2, Math.floor(lower.length / 2));
+    if (dist < bestDist && dist <= threshold) {
+      bestDist = dist;
+      best = id;
+    }
+  }
+  return best;
+}
 function isStreamingFailure(errorName, errorMessage, errorNames = DEFAULT_STREAMING_FAILURE_ERROR_NAMES, messagePatterns = DEFAULT_STREAMING_FAILURE_MESSAGE_PATTERNS) {
   if (!errorName && !errorMessage)
     return false;
@@ -12727,6 +12769,7 @@ var AutoResumePlugin = async (ctx, options) => {
         completionSignaled: false,
         todoNudgeAttempts: 0,
         taskCompleteOverrides: 0,
+        taskCompleteSignals: 0,
         doneClaimNoTodosAttempts: 0,
         lastUserMessageAt: 0,
         pendingTools: 0,
@@ -12735,7 +12778,10 @@ var AutoResumePlugin = async (ctx, options) => {
         pendingRecoveryReason: null,
         pendingRecoveryAt: 0,
         recoveryAttempts: 0,
-        watchdogRetryGuard: false
+        watchdogRetryGuard: false,
+        unknownToolErrors: new Map,
+        unknownToolSuggestionSent: false,
+        checkedToolPartIDs: new Set
       };
       sessions.set(sid, w);
     }
@@ -13054,6 +13100,73 @@ var AutoResumePlugin = async (ctx, options) => {
     messagesInflight.set(sid, p);
     return p;
   }
+  let cachedToolIds = null;
+  let cachedToolIdsAt = 0;
+  async function getAvailableToolIds() {
+    if (cachedToolIds && Date.now() - cachedToolIdsAt < TOOL_IDS_CACHE_MS) {
+      return cachedToolIds;
+    }
+    try {
+      const result = await ctx.client.tool.ids();
+      const ids = result.data ?? [];
+      cachedToolIds = ids;
+      cachedToolIdsAt = Date.now();
+      return ids;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      await log("warn", `Failed to fetch tool IDs: ${msg}`);
+      return cachedToolIds ?? [];
+    }
+  }
+  async function checkForUnknownToolCalls(sid, w) {
+    if (w.unknownToolSuggestionSent)
+      return false;
+    if (w.userCancelled || w.completionSignaled)
+      return false;
+    try {
+      const available = await getAvailableToolIds();
+      if (available.length === 0)
+        return false;
+      const messages = await getSessionMessages(sid);
+      for (const msg of messages) {
+        const parts = msg.parts;
+        if (!parts)
+          continue;
+        for (const part of parts) {
+          const partType = part.type;
+          if (partType !== "tool")
+            continue;
+          const partId = part.id ?? part.callID ?? "";
+          if (!partId || w.checkedToolPartIDs.has(partId))
+            continue;
+          w.checkedToolPartIDs.add(partId);
+          const state = part.state;
+          if (!state || state.status !== "error")
+            continue;
+          const toolName = part.tool ?? "";
+          if (!toolName || available.includes(toolName))
+            continue;
+          const count = (w.unknownToolErrors.get(toolName) ?? 0) + 1;
+          w.unknownToolErrors.set(toolName, count);
+          if (count < UNKNOWN_TOOL_THRESHOLD)
+            continue;
+          const suggestion = suggestClosestTool(toolName, available);
+          const toolList = available.slice(0, 20).join(", ");
+          const prompt = suggestion ? `You tried to use the tool "${toolName}" ${count} times, but it does not exist. ` + `The closest matching tool is "${suggestion}". ` + `Please use "${suggestion}" instead and adjust your arguments accordingly. ` + `Available tools include: ${toolList}.` : `You tried to use the tool "${toolName}" ${count} times, but it does not exist. ` + `Please check the available tools and use the correct one. ` + `Available tools include: ${toolList}.`;
+          w.unknownToolSuggestionSent = true;
+          w.toolTextRecovered = true;
+          await log("warn", `${short(sid)} - unknown tool "${toolName}" called ${count}x, suggesting "${suggestion ?? "(none)"}"`);
+          await sendContinuePrompt(sid, prompt, w);
+          return true;
+        }
+      }
+      return false;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      await log("warn", `${short(sid)} - checkForUnknownToolCalls error: ${msg}`);
+      return false;
+    }
+  }
   function roleOf(msg) {
     if (!msg)
       return;
@@ -13441,6 +13554,15 @@ var AutoResumePlugin = async (ctx, options) => {
         await log("info", `${short(sid)} - user recently active, skipping tool-text check`);
         return;
       }
+      if ((w.todos || []).length === 0) {
+        try {
+          const fetched = await fetchSessionTodos(sid);
+          if (fetched.length > 0)
+            w.todos = fetched;
+        } catch (e) {
+          dbg(`checkForToolCallAsText sid=${short(sid)}: lazy todo fetch error: ${e}`);
+        }
+      }
       const recent = messages.slice(-3);
       let bestCandidate = null;
       let allAssistantText = "";
@@ -14283,6 +14405,9 @@ var AutoResumePlugin = async (ctx, options) => {
           w.status = "idle";
           resetIdleFlags(w);
           dbg(`session.idle sid=${short(sid)}: resetIdleFlags done, toolTextRecovered=${w.toolTextRecovered}, toolTextAttempts=${w.toolTextAttempts}, maxRetries=${maxRetries}`);
+          if (!w.unknownToolSuggestionSent && !w.completionSignaled && !w.userCancelled) {
+            checkForUnknownToolCalls(sid, w);
+          }
           if (resumeOnActionIntent && !w.toolTextRecovered && !w.completionSignaled) {
             setTimeout(async () => {
               try {
@@ -14360,6 +14485,9 @@ var AutoResumePlugin = async (ctx, options) => {
           if (w) {
             w.doneClaimNoTodosAttempts = 0;
             w.lastUserMessageAt = Date.now();
+            w.unknownToolErrors.clear();
+            w.unknownToolSuggestionSent = false;
+            w.checkedToolPartIDs.clear();
           }
           break;
         }
@@ -14452,17 +14580,41 @@ var AutoResumePlugin = async (ctx, options) => {
     }
   }
   const taskCompleteTool = tool({
-    description: "Signal that all work is complete and stop automatic continuation prompts. Call this ONLY after finishing everything requested.",
+    description: "Signal that all work is complete and stop automatic continuation prompts. Call this ONLY after finishing everything requested. Call exactly once per completed round of work \u2014 repeat calls with no new user message in between are rejected.",
     args: {},
     execute: async (_args, ctx) => {
       const w = sessions.get(ctx.sessionID);
       if (w) {
         if (!w.isSubagent) {
+          if ((w.todos || []).length === 0) {
+            try {
+              const fetched = await fetchSessionTodos(ctx.sessionID);
+              if (fetched.length > 0)
+                w.todos = fetched;
+            } catch (e) {
+              dbg(`task_complete sid=${short(ctx.sessionID)}: lazy todo fetch error: ${e}`);
+            }
+          }
           const openTodos = (w.todos || []).filter((t) => t.status === "pending" || t.status === "in_progress");
           if (openTodos.length > 0 && w.taskCompleteOverrides < maxRetries) {
             w.taskCompleteOverrides++;
+            w.taskCompleteSignals = 0;
+            const reminder = buildOpenTodosReminder(w.todos);
+            const blockMsg = `Mark any finished todos complete and do not redo completed work.
+${reminder}`;
             await log("info", `${short(ctx.sessionID)} - task_complete blocked: ${openTodos.length} open todos remain (override ${w.taskCompleteOverrides}/${maxRetries})`);
-            return `You have ${openTodos.length} unfinished task(s). Please complete all remaining work before signaling completion.`;
+            let awaitingInput = false;
+            try {
+              awaitingInput = hasPendingUserInput(await getSessionMessages(ctx.sessionID));
+            } catch (e) {
+              dbg(`task_complete block: awaiting-input check error: ${e}`);
+            }
+            if (awaitingInput) {
+              await log("info", `${short(ctx.sessionID)} - task_complete blocked but user input pending, skipping visible nudge`);
+            } else {
+              await sendContinuePrompt(ctx.sessionID, blockMsg, w);
+            }
+            return blockMsg;
           }
         }
         w.toolTextRecovered = true;
@@ -14472,8 +14624,13 @@ var AutoResumePlugin = async (ctx, options) => {
           w.toolTextTimer = null;
         }
         log("info", `${short(ctx.sessionID)} - task_complete called, ${w.isSubagent ? "subagent" : "agent"} done`);
+        w.taskCompleteSignals++;
+        if (w.taskCompleteSignals === 2)
+          return TASK_COMPLETE_REPEAT_WARNING;
+        if (w.taskCompleteSignals > 2)
+          throw new Error(TASK_COMPLETE_REPEAT_ERROR);
       }
-      return "Task completion acknowledged. No further continuation will be sent.";
+      return TASK_COMPLETE_ACK;
     }
   });
   return {
@@ -14505,6 +14662,7 @@ var AutoResumePlugin = async (ctx, options) => {
       if (w.userCancelled || w.completionSignaled) {
         w.userCancelled = false;
         w.completionSignaled = false;
+        w.taskCompleteSignals = 0;
         await log("info", `${short(sid)} - new user message, re-arming auto-resume`);
       }
     },
@@ -14515,6 +14673,8 @@ var AutoResumePlugin = async (ctx, options) => {
       w.pendingTools++;
       w.lastActivityAt = Date.now();
       const toolName = input.tool ?? "unknown";
+      if (toolName !== "task_complete")
+        w.taskCompleteSignals = 0;
       const rawArgs = hookArgs?.args ?? input.args;
       w.liveToolSigs.push(toolCallSignature(toolName, rawArgs));
       if (w.liveToolSigs.length > 15)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auto-resume",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "OpenCode plugin that automatically resumes stalled LLM sessions when thinking/streaming freezes mid-generation.",
   "keywords": [
     "opencode",