opencode-auto-resume 1.0.16 → 1.0.17

package/dist/index.js

@@ -12351,6 +12351,7 @@ var IDLE_CLEANUP_MS = 10 * 60000;
 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 TOOL_TEXT_PATTERNS = [
   /<function\s*=/i,
   /<function>/i,
@@ -12461,9 +12462,7 @@ var AutoResumePlugin = async (ctx, options) => {
   }
   async function log(level, msg) {
     try {
-      await ctx.client.app.log({
-        body: { service: "auto-resume", level, message: msg }
-      });
+      await ctx.client.app.log({ body: { service: "auto-resume", level, message: msg } });
     } catch {}
   }
   function ensureWatch(sid) {
@@ -12488,7 +12487,9 @@ var AutoResumePlugin = async (ctx, options) => {
         toolTextTimer: null,
         checkingToolText: false,
         lastSubagentCheckAt: 0,
-        interruptedContinueCount: 0
+        interruptedContinueCount: 0,
+        recentToolCalls: [],
+        toolLoopAttempts: 0
       };
       sessions.set(sid, w);
     }
@@ -12731,6 +12732,8 @@ var AutoResumePlugin = async (ctx, options) => {
     w.todoCheckAttempts = 0;
     w.checkingToolText = false;
     w.interruptedContinueCount = 0;
+    w.recentToolCalls = [];
+    w.toolLoopAttempts = 0;
     if (w.toolTextTimer) {
       clearTimeout(w.toolTextTimer);
       w.toolTextTimer = null;
@@ -12742,6 +12745,41 @@ var AutoResumePlugin = async (ctx, options) => {
     w.orphanWatchStartAt = null;
     w.idleSince = Date.now();
   }
+  function detectPatternLoop(recentTools) {
+    if (recentTools.length < 6)
+      return false;
+    for (const patternLen of [2, 3, 4, 5]) {
+      if (recentTools.length < patternLen * 3)
+        continue;
+      const pattern = recentTools.slice(-patternLen);
+      let matches = 0;
+      for (let i = recentTools.length - patternLen * 2;i >= 0; i -= patternLen) {
+        const slice = recentTools.slice(i, i + patternLen);
+        if (slice.length !== patternLen)
+          break;
+        const isMatch = slice.every((tool3, idx) => tool3 === pattern[idx]);
+        if (!isMatch)
+          break;
+        matches++;
+      }
+      if (matches >= 2)
+        return true;
+    }
+    return false;
+  }
+  function trackToolCall(w, toolName2) {
+    const now = Date.now();
+    w.recentToolCalls = w.recentToolCalls.filter((call) => now - call.at < 120000);
+    w.recentToolCalls.push({ toolName: toolName2, at: now });
+    const recentTools = w.recentToolCalls.slice(-15).map((call) => call.toolName);
+    if (recentTools.length < 6)
+      return false;
+    const lastTool = recentTools[recentTools.length - 1];
+    const consecutiveSame = recentTools.slice(-5).filter((tool3) => tool3 === lastTool).length;
+    if (consecutiveSame >= 3)
+      return true;
+    return detectPatternLoop(recentTools);
+  }
   async function checkForToolCallAsText(sid, w) {
     if (typeof sid !== "string" || !sid)
       return;
@@ -12773,6 +12811,24 @@ var AutoResumePlugin = async (ctx, options) => {
         const rawRole = msg.role ?? msg.info?.role;
         if (rawRole !== "assistant")
           continue;
+        const toolCall = msg.toolCall;
+        if (toolCall && typeof toolCall === "object" && "name" in toolCall) {
+          const toolName2 = toolCall.name;
+          if (toolName2) {
+            trackToolCall(w, toolName2);
+          }
+        }
+        const toolCalls = msg.tool_calls;
+        if (toolCalls) {
+          for (const tc of toolCalls) {
+            if (typeof tc === "object" && "name" in tc) {
+              const toolName2 = tc.name;
+              if (toolName2) {
+                trackToolCall(w, toolName2);
+              }
+            }
+          }
+        }
         const parts = msg.parts;
         if (!parts)
           continue;
@@ -12788,21 +12844,34 @@ var AutoResumePlugin = async (ctx, options) => {
             isReasoning = true;
           } else if (partType === "tool_use") {
             isToolUse = true;
-            const toolName = part.name ?? "unknown";
-            text = `tool_use: ${toolName}`;
+            const toolName2 = part.name ?? "unknown";
+            text = `tool_use: ${toolName2}`;
           } else {
             continue;
           }
           allAssistantText += text + `
 `;
           if (isToolUse) {
-            const candidate = {
-              prompt: "continue",
-              source: "tool-use",
-              priority: 1
-            };
-            if (!bestCandidate || candidate.priority < bestCandidate.priority) {
-              bestCandidate = candidate;
+            const isLoop = trackToolCall(w, toolName);
+            if (isLoop && w.toolLoopAttempts < 2) {
+              w.toolLoopAttempts++;
+              const candidate = {
+                prompt: TOOL_LOOP_RECOVERY_PROMPT,
+                source: "tool-loop",
+                priority: 0
+              };
+              if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+                bestCandidate = candidate;
+              }
+            } else {
+              const candidate = {
+                prompt: "continue",
+                source: "tool-use",
+                priority: 1
+              };
+              if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+                bestCandidate = candidate;
+              }
             }
           }
           if (containsToolCallAsText(text)) {
@@ -12872,13 +12941,15 @@ var AutoResumePlugin = async (ctx, options) => {
       if (!bestCandidate) {
         const todos = w.todos || [];
         const hasOpenTodos = todos.some((t) => t.status === "pending" || t.status === "in_progress");
-        if (hasOpenTodos) {
+        if (hasOpenTodos && busyCount() === 1) {
           await log("info", `${short(sid)} - no activity detected but todos remain open (${todos.filter((t) => t.status === "pending" || t.status === "in_progress").length} tasks). Sending continue...`);
           bestCandidate = {
             prompt: "continue",
             source: "idle-with-open-todos",
             priority: 2
           };
+        } else if (hasOpenTodos && busyCount() > 1) {
+          await log("debug", `${short(sid)} - todos remain open but ${busyCount()} sessions busy (subagents running), skipping continue`);
         }
       }
       if (!bestCandidate)

package/package.json

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