opencode-auto-resume 1.0.5 → 1.0.7

package/README.md

@@ -7,6 +7,8 @@
 LLM sessions fail in predictable ways. This plugin monitors all sessions and automatically recovers without user intervention.
 
 **Stall recovery** — the stream goes silent but the session stays "busy". The UI shows a blinking cursor with no progress. If no events arrive for 48 seconds, the plugin sends `"continue"` with exponential backoff. After 3 failed attempts it gives up.
+
+The plugin extracts the **agent, model, and provider** from the last session message, so it resumes with the exact same configuration the user was using (build, sisyphus, prometheus, etc.).
 _( [#55](https://github.com/opencode-ai/opencode/issues/55), [#199](https://github.com/opencode-ai/opencode/issues/199), [#283](https://github.com/opencode-ai/opencode/issues/283) )_
 
 **Tool calls as raw text** — the model prints tool invocations as raw XML (`<function=edit>...`) instead of executing them. The session goes idle normally but the tool was never run. On idle, the plugin fetches the last messages and scans for XML tool-call patterns (including truncated and alternative formats). If found, it sends a specific recovery prompt.

package/dist/index.js

@@ -15,6 +15,7 @@ var MAX_IDLE_SESSIONS = 50;
 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_TEXT_PATTERNS = [
   /<function\s*=/i,
   /<function>/i,
@@ -210,12 +211,53 @@ var AutoResumePlugin = async (ctx, options) => {
     }
     w.continuing = true;
     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--) {
+        const msg = msgs[i];
+        const info = msg.info;
+        if (info?.role === "user") {
+          const rawAgent = info.agent;
+          if (typeof rawAgent === "string")
+            agent2 = rawAgent;
+          const rawModel = 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 }] }
+        body: {
+          parts: [{ type: "text", text }],
+          agent: agent2,
+          model: model2
+        }
       });
+      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) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      await log("warn", `${short(sid)} - prompt failed: ${errMsg}`);
+      try {
+        await ctx.client.session.prompt({
+          path: { id: sid },
+          body: { parts: [{ type: "text", text }], agent, model }
+        });
+        recordContinue(sid);
+        w.lastRetryAt = Date.now();
+      } catch (retryErr) {
+        const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+        await log("error", `${short(sid)} - prompt retry also failed: ${retryMsg}`);
+        throw retryErr;
+      }
     } finally {
       w.continuing = false;
     }
@@ -229,6 +271,38 @@ var AutoResumePlugin = async (ctx, options) => {
       return response.messages;
     return [];
   }
+  async function checkSubagentStatus(parentSid) {
+    try {
+      const response = await ctx.client.session.list();
+      const allSessions = extractMessages(response);
+      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];
+          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";
+          }
+        }
+      }
+      if (!hasBusySubagent) {
+        return "idle";
+      }
+      return "busy";
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      await log("debug", `checkSubagentStatus failed: ${errMsg}`);
+      return "unknown";
+    }
+  }
   function resetSessionFlags(w) {
     w.userCancelled = false;
     w.resumeAttempts = 0;
@@ -267,55 +341,65 @@ 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)
           continue;
         for (const part of parts) {
-          if (part.type !== "text")
+          const partType = part.type;
+          let text = "";
+          let isReasoning = false;
+          if (partType === "text") {
+            text = part.text ?? "";
+          } else if (partType === "reasoning") {
+            text = part.text ?? "";
+            isReasoning = true;
+          } else {
             continue;
-          const text = part.text ?? "";
+          }
           if (containsToolCallAsText(text)) {
-            w.toolTextRecovered = true;
-            w.toolTextAttempts++;
-            await log("info", `Tool-call-as-text 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, TOOL_TEXT_RECOVERY_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}`);
@@ -412,7 +496,7 @@ var AutoResumePlugin = async (ctx, options) => {
   function startTimer() {
     if (timer)
       return;
-    timer = setInterval(() => {
+    timer = setInterval(async () => {
       const now = Date.now();
       const numBusy = busyCount();
       for (const [sid, w] of sessions) {
@@ -426,7 +510,16 @@ var AutoResumePlugin = async (ctx, options) => {
           const orphanIdle = now - w.orphanWatchStartAt;
           if (orphanIdle >= subagentWaitMs + gracePeriodMs) {
             if (w.resumeAttempts < maxRetries) {
-              tryAbortAndResume(sid, w);
+              const subStatus = await checkSubagentStatus(sid);
+              if (subStatus === "crashed") {
+                await log("info", `Subagent crashed, triggering abort+resume on ${short(sid)}`);
+                tryAbortAndResume(sid, w);
+              } else if (subStatus === "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...`);
+              }
             } else if (!w.gaveUp) {
               w.gaveUp = true;
               w.orphanWatchStartAt = null;

package/package.json

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