opencode-auto-resume 1.0.19 → 1.0.21

package/dist/index.js

@@ -12583,9 +12583,9 @@ var AutoResumePlugin = async (ctx, options) => {
       return;
     }
     w.continuing = true;
+    let agent;
+    let model;
     try {
-      let agent2;
-      let model2;
       const msgResp = await ctx.client.session.messages({ path: { id: sid } });
       const msgs = extractMessages(msgResp);
       for (let i = msgs.length - 1;i >= 0; i--) {
@@ -12594,11 +12594,11 @@ var AutoResumePlugin = async (ctx, options) => {
         if (role === "user") {
           const rawAgent = msg.agent;
           if (typeof rawAgent === "string") {
-            agent2 = rawAgent;
+            agent = rawAgent;
           } else {
             const fallbackAgent = msg.info?.agent;
             if (typeof fallbackAgent === "string") {
-              agent2 = fallbackAgent;
+              agent = fallbackAgent;
             }
           }
           let rawModel = msg.model;
@@ -12606,7 +12606,7 @@ var AutoResumePlugin = async (ctx, options) => {
             rawModel = msg.info?.model;
           }
           if (rawModel && typeof rawModel.providerID === "string" && typeof rawModel.modelID === "string") {
-            model2 = {
+            model = {
               providerID: rawModel.providerID,
               modelID: rawModel.modelID
             };
@@ -12618,11 +12618,11 @@ var AutoResumePlugin = async (ctx, options) => {
         path: { id: sid },
         body: {
           parts: [{ type: "text", text }],
-          agent: agent2,
-          model: model2
+          agent,
+          model
         }
       });
-      await log("debug", `${short(sid)} - prompt sent with agent: ${agent2 ?? "(default)"}, model: ${model2 ? `${model2.providerID}/${model2.modelID}` : "(default)"}`);
+      await log("debug", `${short(sid)} - prompt sent with agent: ${agent ?? "(default)"}, model: ${model ? `${model.providerID}/${model.modelID}` : "(default)"}`);
       recordContinue(sid);
       w.lastRetryAt = Date.now();
     } catch (err) {
@@ -12679,6 +12679,54 @@ var AutoResumePlugin = async (ctx, options) => {
       return false;
     }
   }
+  async function hasBusySubagents(parentSid) {
+    try {
+      const response = await ctx.client.session.list();
+      const allSessions = extractMessages(response);
+      for (const s of allSessions) {
+        const sId = s.id;
+        if (!sId || sId === parentSid)
+          continue;
+        const status = s.status;
+        if (status === "busy")
+          return true;
+      }
+      return false;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      await log("debug", `hasBusySubagents failed for ${short(parentSid)}: ${errMsg}`);
+      return false;
+    }
+  }
+  async function checkSessionHasActiveTool(sid) {
+    try {
+      const listResponse = await ctx.client.session.list();
+      const sessions2 = extractMessages(listResponse);
+      const currentSession = sessions2.find((s) => s.id === sid);
+      const status = currentSession?.status;
+      if (status === "busy") {
+        await log("debug", `Session ${short(sid)} is busy, likely executing a tool`);
+        return true;
+      }
+      const response = await ctx.client.session.messages({ path: { id: sid } });
+      const messages = extractMessages(response);
+      const lastMsg = messages[messages.length - 1];
+      if (!lastMsg)
+        return false;
+      const rawRole = lastMsg?.role ?? lastMsg?.info?.role;
+      if (rawRole !== "assistant")
+        return false;
+      const toolCall = lastMsg.toolCall;
+      const toolCalls = lastMsg.tool_calls;
+      const parts = lastMsg.parts;
+      const hasToolCall = toolCall !== undefined || (toolCalls?.length ?? 0) > 0 || (parts?.some((p) => p.type === "tool-call" || p.type === "tool_use") ?? false);
+      return hasToolCall;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      await log("debug", `checkSessionHasActiveTool failed for ${short(sid)}: ${errMsg}`);
+      return false;
+    }
+  }
   async function checkSubagentStatus(parentSid) {
     try {
       const response = await ctx.client.session.list();
@@ -12698,10 +12746,15 @@ var AutoResumePlugin = async (ctx, options) => {
           const rawRole = lastMsg?.role ?? lastMsg?.info?.role;
           if (lastMsg && rawRole === "assistant" && (("error" in lastMsg) || lastMsg.info && ("error" in lastMsg.info))) {
             await log("debug", `Subagent ${short(sId)} appears crashed`);
-            return "crashed";
+            return { status: "crashed" };
           }
           const msgTime = lastMsg?.time?.created ?? lastMsg?.time;
-          const hasToolCall = lastMsg?.toolCall !== undefined || lastMsg?.tool_calls !== undefined || lastMsg?.parts?.some((p) => p.type === "tool-call") !== undefined;
+          if (!msgTime)
+            continue;
+          const toolCall = lastMsg.toolCall;
+          const toolCalls = lastMsg.tool_calls;
+          const parts = lastMsg.parts;
+          const hasToolCall = toolCall !== undefined || (toolCalls?.length ?? 0) > 0 || (parts?.some((p) => p.type === "tool-call") ?? false);
           const isStuck = hasToolCall ? now - msgTime > SUBAGENT_STUCK_MS * 3 : now - msgTime > SUBAGENT_STUCK_MS;
           if (isStuck) {
             await log("debug", `Subagent ${short(sId)} stuck - no new text in >${hasToolCall ? 3 : 1}min`);
@@ -12770,10 +12823,10 @@ var AutoResumePlugin = async (ctx, options) => {
     }
     return false;
   }
-  function trackToolCall(w, toolName2) {
+  function trackToolCall(w, toolName) {
     const now = Date.now();
     w.recentToolCalls = w.recentToolCalls.filter((call) => now - call.at < 120000);
-    w.recentToolCalls.push({ toolName: toolName2, at: now });
+    w.recentToolCalls.push({ toolName, at: now });
     const recentTools = w.recentToolCalls.slice(-15).map((call) => call.toolName);
     if (recentTools.length < 6)
       return false;
@@ -12816,18 +12869,18 @@ var AutoResumePlugin = async (ctx, options) => {
           continue;
         const toolCall = msg.toolCall;
         if (toolCall && typeof toolCall === "object" && "name" in toolCall) {
-          const toolName2 = toolCall.name;
-          if (toolName2) {
-            trackToolCall(w, toolName2);
+          const toolName = toolCall.name;
+          if (toolName) {
+            trackToolCall(w, toolName);
           }
         }
         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 toolName = tc.name;
+              if (toolName) {
+                trackToolCall(w, toolName);
               }
             }
           }
@@ -12847,14 +12900,15 @@ var AutoResumePlugin = async (ctx, options) => {
             isReasoning = true;
           } else if (partType === "tool_use") {
             isToolUse = true;
-            const toolName2 = part.name ?? "unknown";
-            text = `tool_use: ${toolName2}`;
+            const toolName = part.name ?? "unknown";
+            text = `tool_use: ${toolName}`;
           } else {
             continue;
           }
           allAssistantText += text + `
 `;
           if (isToolUse) {
+            const toolName = part.name ?? "unknown";
             const isLoop = trackToolCall(w, toolName);
             if (isLoop && w.toolLoopAttempts < 2) {
               w.toolLoopAttempts++;
@@ -12880,8 +12934,8 @@ var AutoResumePlugin = async (ctx, options) => {
           if (containsToolCallAsText(text)) {
             const toolMatch = text.match(/<function=([a-zA-Z_]+)/) || text.match(/<invoke\s+name=([a-zA-Z_]+)/) || text.match(/"name":\s*"([a-zA-Z_]+)/);
             if (toolMatch) {
-              const toolName2 = toolMatch[1] || "unknown";
-              const isLoop = trackToolCall(w, toolName2);
+              const toolName = toolMatch[1] || "unknown";
+              const isLoop = trackToolCall(w, toolName);
               if (isLoop && w.toolLoopAttempts < 2) {
                 w.toolLoopAttempts++;
                 const loopCandidate = {
@@ -13117,8 +13171,13 @@ var AutoResumePlugin = async (ctx, options) => {
                   tryAbortAndResume(sid, w);
                 }
               } else if (subStatus.status === "idle") {
-                await log("info", `All subagents idle, parent ${short(sid)} stuck. Triggering abort+resume.`);
-                tryAbortAndResume(sid, w);
+                const hasBusySub = await hasBusySubagents(sid);
+                if (hasBusySub) {
+                  await log("debug", `Subagents exist but not busy yet, waiting for startup...`);
+                } else {
+                  await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
+                  tryAbortAndResume(sid, w);
+                }
               } else {
                 await log("debug", `Subagent still running, waiting...`);
               }
@@ -13137,6 +13196,12 @@ var AutoResumePlugin = async (ctx, options) => {
           continue;
         w.lastSubagentCheckAt = now;
         if (w.lastActivityAt > 0 && now - w.lastActivityAt > subagentWaitMs) {
+          const hasActiveTool = await checkSessionHasActiveTool(sid);
+          if (hasActiveTool) {
+            await log("debug", `Parent ${short(sid)} has active tool call, skipping abort check`);
+            w.lastSubagentCheckAt = now;
+            continue;
+          }
           const subStatus = await checkSubagentStatus(sid);
           if (subStatus.status === "idle" || subStatus.status === "unknown") {
             await log("info", `Parent ${short(sid)} stuck with no active subagents. Triggering abort+resume.`);
@@ -13365,14 +13430,6 @@ var AutoResumePlugin = async (ctx, options) => {
     },
     config: async () => {
       log("info", `opencode-auto-resume config OK`);
-      if (ctx.ui && typeof ctx.ui.toast === "function") {
-        ctx.ui.toast({
-          title: "Auto-Resume Plugin",
-          message: `Loaded with ${chunkTimeoutMs}ms timeout, ${loopMaxContinues} loop attempts`,
-          variant: "success",
-          duration: 5000
-        });
-      }
     },
     tool: {
       task_complete: taskCompleteTool

package/package.json

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