opencode-auto-resume 1.0.6 → 1.0.8

package/README.md

@@ -30,6 +30,12 @@ _( [#128](https://github.com/opencode-ai/opencode/pulls/128), [#22](https://gith
 
 **Session discovery** — periodically calls `session.list()` to pick up sessions that were missed by event tracking. Idle sessions are cleaned up after 10 minutes to prevent memory leaks.
 
+**Model preservation** — when resuming with "continue", the plugin extracts agent, model and provider from the last session message (not from `info` field) to preserve the user's UI selection.
+_( [#111](https://github.com/opencode-ai/opencode/issues/111), [#277](https://github.com/opencode-ai/opencode/issues/277) )_
+
+**Subagent stuck detection** — detects when a subagent hasn't received new text for >1 minute (or >3 minutes if a tool call is in progress). If stuck, sends a recovery prompt before triggering abort+resume on the parent.
+_( [#55](https://github.com/opencode-ai/opencode/issues/55), [#60](https://github.com/opencode-ai/opencode/issues/60), [#246](https://github.com/opencode-ai/opencode/issues/246) )_
+
 ## Architecture
 
 ```

package/dist/index.js

@@ -211,28 +211,39 @@ var AutoResumePlugin = async (ctx, options) => {
     }
     w.continuing = true;
     try {
-      let agent;
-      let modelID;
-      let providerID;
+      let agent2;
+      let model2;
       const msgResp = await ctx.client.session.messages({ path: { id: sid } });
       const msgs = extractMessages(msgResp);
-      const lastMsg = msgs[msgs.length - 1];
-      if (lastMsg) {
-        const info = lastMsg.info;
-        agent = info?.agent;
-        if (lastMsg.role === "assistant") {
-          modelID = lastMsg.modelID;
-          providerID = lastMsg.providerID;
+      for (let i = msgs.length - 1;i >= 0; i--) {
+        const msg = msgs[i];
+        const role = msg.role ?? msg.info?.role;
+        if (role === "user") {
+          const rawAgent = msg.agent;
+          if (typeof rawAgent === "string")
+            agent2 = rawAgent;
+          let rawModel = msg.model;
+          if (!rawModel) {
+            rawModel = msg.info?.model;
+          }
+          if (rawModel && typeof rawModel.providerID === "string" && typeof rawModel.modelID === "string") {
+            model2 = {
+              providerID: rawModel.providerID,
+              modelID: rawModel.modelID
+            };
+          }
+          break;
         }
       }
       await ctx.client.session.prompt({
         path: { id: sid },
-        body: { parts: [{ type: "text", text }] },
-        agent,
-        modelID,
-        providerID
+        body: {
+          parts: [{ type: "text", text }],
+          agent: agent2,
+          model: model2
+        }
       });
-      await log("debug", `${short(sid)} - prompt sent with agent: ${agent}, model: ${modelID}`);
+      await log("debug", `${short(sid)} - prompt sent with agent: ${agent2 ?? "(default)"}, model: ${model2 ? `${model2.providerID}/${model2.modelID}` : "(default)"}`);
       recordContinue(sid);
       w.lastRetryAt = Date.now();
     } catch (err) {
@@ -241,7 +252,7 @@ var AutoResumePlugin = async (ctx, options) => {
       try {
         await ctx.client.session.prompt({
           path: { id: sid },
-          body: { parts: [{ type: "text", text }] }
+          body: { parts: [{ type: "text", text }], agent, model }
         });
         recordContinue(sid);
         w.lastRetryAt = Date.now();
@@ -263,32 +274,61 @@ var AutoResumePlugin = async (ctx, options) => {
       return response.messages;
     return [];
   }
-  async function checkSubagentCrashed(parentSid) {
+  const SUBAGENT_STUCK_MS = 60000;
+  const SUBAGENT_RECOVERY_PROMPT = "It looks like you may have stalled or timed out. Please retry the last operation or continue with the task.";
+  async function recoverSubagent(subagentSid) {
+    try {
+      await ctx.client.session.prompt({
+        path: { id: subagentSid },
+        body: { parts: [{ type: "text", text: SUBAGENT_RECOVERY_PROMPT }] }
+      });
+      await log("info", `Sent recovery prompt to subagent ${short(subagentSid)}`);
+      return true;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      await log("warn", `Failed to recover subagent ${short(subagentSid)}: ${errMsg}`);
+      return false;
+    }
+  }
+  async function checkSubagentStatus(parentSid) {
     try {
       const response = await ctx.client.session.list();
-      const sessions2 = extractMessages(response);
-      for (const s of sessions2) {
+      const allSessions = extractMessages(response);
+      const now = Date.now();
+      let hasBusySubagent = false;
+      for (const s of allSessions) {
         const sId = s.id;
         if (!sId || sId === parentSid)
           continue;
         const status = s.status;
         if (status === "busy") {
+          hasBusySubagent = true;
           const msgResponse = await ctx.client.session.messages({ path: { id: sId } });
           const messages = extractMessages(msgResponse);
           const lastMsg = messages[messages.length - 1];
-          if (lastMsg && lastMsg.role === "assistant" && "error" in lastMsg) {
-            const error = lastMsg.error;
-            const errorName = error?.name;
-            await log("debug", `Subagent ${short(sId)} appears crashed: ${errorName}`);
-            return true;
+          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";
+          }
+          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;
+          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`);
+            return { status: "crashed", stuckSid: sId };
           }
         }
       }
+      if (!hasBusySubagent) {
+        return { status: "idle" };
+      }
+      return { status: "busy" };
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
-      await log("debug", `checkSubagentCrashed failed: ${errMsg}`);
+      await log("debug", `checkSubagentStatus failed: ${errMsg}`);
+      return { status: "unknown" };
     }
-    return false;
   }
   function resetSessionFlags(w) {
     w.userCancelled = false;
@@ -328,9 +368,10 @@ var AutoResumePlugin = async (ctx, options) => {
       });
       const messages = extractMessages(response);
       const recent = messages.slice(-3);
+      let bestCandidate = null;
       for (const msg of recent) {
-        const role = msg.role;
-        if (role !== "assistant")
+        const rawRole = msg.role ?? msg.info?.role;
+        if (rawRole !== "assistant")
           continue;
         const parts = msg.parts;
         if (!parts)
@@ -348,45 +389,44 @@ var AutoResumePlugin = async (ctx, options) => {
             continue;
           }
           if (containsToolCallAsText(text)) {
-            w.toolTextRecovered = true;
-            w.toolTextAttempts++;
-            const prompt = isReasoning ? THINKING_TOOL_RECOVERY_PROMPT : TOOL_TEXT_RECOVERY_PROMPT;
-            const source = isReasoning ? "reasoning" : "text";
-            await log("info", `Tool-call-as-text in ${source} detected on ${short(sid)}! ` + `Attempt ${w.toolTextAttempts}/${maxRetries}. Sending recovery prompt...`);
-            if (isHallucinationLoop(sid)) {
-              await log("warn", `Hallucination loop detected on ${short(sid)} \u2014 aborting instead`);
-              await tryAbortAndResume(sid, w);
-            } else {
-              try {
-                await sendContinuePrompt(sid, prompt, w);
-                await log("info", `${short(sid)} - tool-call-as-text recovery sent (attempt ${w.toolTextAttempts})`);
-              } catch (err) {
-                const errMsg = err instanceof Error ? err.message : String(err);
-                await log("warn", `${short(sid)} - tool-call-as-text recovery failed: ${errMsg}`);
-              }
+            const candidate = {
+              prompt: isReasoning ? THINKING_TOOL_RECOVERY_PROMPT : TOOL_TEXT_RECOVERY_PROMPT,
+              source: isReasoning ? "reasoning" : "text",
+              priority: 0
+            };
+            if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+              bestCandidate = candidate;
             }
-            return;
           }
           if (containsReadyToContinuePattern(text)) {
-            w.toolTextRecovered = true;
-            w.toolTextAttempts++;
-            await log("info", `Ready-to-continue pattern detected on ${short(sid)}! ` + `Attempt ${w.toolTextAttempts}/${maxRetries}. Sending continue...`);
-            if (isHallucinationLoop(sid)) {
-              await log("warn", `Hallucination loop detected on ${short(sid)} \u2014 aborting instead`);
-              await tryAbortAndResume(sid, w);
-            } else {
-              try {
-                await sendContinuePrompt(sid, "continue", w);
-                await log("info", `${short(sid)} - ready-to-continue recovery sent (attempt ${w.toolTextAttempts})`);
-              } catch (err) {
-                const errMsg = err instanceof Error ? err.message : String(err);
-                await log("warn", `${short(sid)} - ready-to-continue recovery failed: ${errMsg}`);
-              }
+            const candidate = {
+              prompt: "continue",
+              source: "ready-to-continue",
+              priority: 1
+            };
+            if (!bestCandidate || candidate.priority < bestCandidate.priority) {
+              bestCandidate = candidate;
             }
-            return;
           }
         }
       }
+      if (!bestCandidate)
+        return;
+      w.toolTextRecovered = true;
+      w.toolTextAttempts++;
+      await log("info", `${bestCandidate.source} detected on ${short(sid)}! ` + `Attempt ${w.toolTextAttempts}/${maxRetries}. Sending recovery prompt...`);
+      if (isHallucinationLoop(sid)) {
+        await log("warn", `Hallucination loop detected on ${short(sid)} \u2014 aborting instead`);
+        await tryAbortAndResume(sid, w);
+      } else {
+        try {
+          await sendContinuePrompt(sid, bestCandidate.prompt, w);
+          await log("info", `${short(sid)} - ${bestCandidate.source} recovery sent (attempt ${w.toolTextAttempts})`);
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          await log("warn", `${short(sid)} - ${bestCandidate.source} recovery failed: ${errMsg}`);
+        }
+      }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       log("debug", `${short(sid)} - could not fetch messages: ${errMsg}`);
@@ -497,9 +537,17 @@ var AutoResumePlugin = async (ctx, options) => {
           const orphanIdle = now - w.orphanWatchStartAt;
           if (orphanIdle >= subagentWaitMs + gracePeriodMs) {
             if (w.resumeAttempts < maxRetries) {
-              const crashed = await checkSubagentCrashed(sid);
-              if (crashed) {
-                await log("info", `Subagent crashed, triggering abort+resume on ${short(sid)}`);
+              const subStatus = await checkSubagentStatus(sid);
+              if (subStatus.status === "crashed" && subStatus.stuckSid) {
+                const recovered = await recoverSubagent(subStatus.stuckSid);
+                if (recovered) {
+                  await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
+                } else {
+                  await log("info", `Subagent crashed, triggering abort+resume on ${short(sid)}`);
+                  tryAbortAndResume(sid, w);
+                }
+              } else if (subStatus.status === "idle") {
+                await log("info", `All subagents idle, parent ${short(sid)} stuck. Triggering abort+resume.`);
                 tryAbortAndResume(sid, w);
               } else {
                 await log("debug", `Subagent still running, waiting...`);
@@ -515,6 +563,23 @@ var AutoResumePlugin = async (ctx, options) => {
         }
         if (numBusy > 1)
           continue;
+        if (w.lastActivityAt > 0 && now - w.lastActivityAt > subagentWaitMs) {
+          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.`);
+            tryAbortAndResume(sid, w);
+            continue;
+          } else if (subStatus.status === "crashed" && subStatus.stuckSid) {
+            const recovered = await recoverSubagent(subStatus.stuckSid);
+            if (recovered) {
+              await log("info", `Sent recovery prompt to stuck subagent ${short(subStatus.stuckSid)}, waiting...`);
+            } else {
+              await log("info", `Parent ${short(sid)} subagent recovery failed. Triggering abort+resume.`);
+              tryAbortAndResume(sid, w);
+            }
+            continue;
+          }
+        }
         const idle = now - w.lastActivityAt;
         if (idle >= chunkTimeoutMs + gracePeriodMs) {
           if (w.resumeAttempts < maxRetries) {

package/package.json

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