@monotykamary/pi-retry 0.3.10 → 0.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-retry",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Extension suite for pi coding agent that handles 400/413 errors and connection errors with automatic retry",
   "type": "module",
   "author": "Tom X Nguyen",

package/retry.ts

@@ -90,7 +90,9 @@ Agent.prototype.continue = function (this: Agent) {
             lastMsg.stopReason !== 'stop' &&
             lastMsg.stopReason !== 'aborted') {
           // Agent was mid-task (toolUse, length, or error) — fall back to prompt([])
-          if (!_continueInProgress) {
+          // Guard: if triggerInvisibleContinue() just completed (within 500ms),
+          // the agent already continued — skip to avoid double continuation.
+          if (!_continueInProgress && Date.now() - _lastInvisibleContinueTime > 500) {
             _continueInProgress = true;
             try {
               await self.prompt([]);
@@ -121,12 +123,22 @@ const stateOther = new RetryState();
 // Max_tokens continuation state (indefinite — no cap needed)
 const stateContinuation = new ContinuationState();
 
+// Abort flag: set when turn_end reports stopReason "aborted", cleared on
+// session_start and on fresh user activity.  Prevents triggerInvisibleContinue()
+// from driving a new prompt([]) after the user explicitly cancelled.
+let _userAborted = false;
+
 // Mutex: only one triggerInvisibleContinue may be in-flight at a time.
 // Without this, concurrent agent_end events (or a manual /retry during an
 // automatic retry) race through waitForIdle() and both call prompt([]),
 // producing "Agent is already processing".
 let _continueInProgress = false;
 
+// Timestamp of the last completed triggerInvisibleContinue().
+// Used by the continue() monkey-patch to avoid double continuation when
+// triggerInvisibleContinue just ran and the session's continue() unblocks.
+let _lastInvisibleContinueTime = 0;
+
 // Sleep helper
 function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
@@ -148,6 +160,9 @@ export default function (pi: ExtensionAPI) {
         // Do NOT reset continuation state — a user abort of a continuation
         // turn is different from aborting an error retry.
         stateContinuation.endContinuation();
+        // Signal to any in-flight triggerInvisibleContinue or pending retry
+        // that the user has cancelled — don't drive a new prompt([]).
+        _userAborted = true;
         return;
       }
       if (msg.stopReason !== "length") {
@@ -157,6 +172,9 @@ export default function (pi: ExtensionAPI) {
         stateConnection.succeed();
         stateOther.succeed();
         stateContinuation.complete();
+        // Clear abort flag — this is a fresh successful turn, so any
+        // previous abort is stale and shouldn't block future retries.
+        _userAborted = false;
       }
     }
   });
@@ -170,6 +188,9 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
+    // Guard: if the user aborted, don't drive any new prompt([])
+    if (_userAborted) return;
+
     // Check for max_tokens stop — auto-continue (invisible to LLM)
     if (hasMaxTokensStop(lastAssistant) && !stateContinuation.getIsContinuing()) {
       stateContinuation.startContinuation();
@@ -211,6 +232,15 @@ export default function (pi: ExtensionAPI) {
       const delay = calculateDelay(state.getAttempt());
 
       await sleep(delay);
+
+      // Re-check: user may have aborted during the backoff sleep.
+      // turn_end with stopReason "aborted" sets _userAborted, but this
+      // handler was already past the initial check.
+      if (_userAborted) {
+        state.endRetry();
+        return;
+      }
+
       // Must NOT await — see triggerInvisibleContinue() for explanation
       void triggerInvisibleContinue();
       state.endRetry();
@@ -298,6 +328,7 @@ export default function (pi: ExtensionAPI) {
         stateConnection.reset();
         stateOther.reset();
         stateContinuation.reset();
+        _userAborted = false;
         ctx.ui.notify("All retry counters reset", "info");
         return;
       }
@@ -311,6 +342,10 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
+      // Manual /retry overrides any previous abort — the user is
+      // explicitly requesting a retry, so clear the abort flag.
+      _userAborted = false;
+
       // Auto-detect: max_tokens continuation takes priority
       if (hasMaxTokensStop(lastAssistant)) {
         ctx.ui.notify("Manually continuing after max_tokens...", "info");
@@ -361,6 +396,8 @@ export default function (pi: ExtensionAPI) {
     stateOther.reset();
     stateContinuation.reset();
     _continueInProgress = false;
+    _lastInvisibleContinueTime = 0;
+    _userAborted = false;
   });
 
   // Resume the agent loop invisibly — no message injected into context.
@@ -374,6 +411,12 @@ export default function (pi: ExtensionAPI) {
   async function triggerInvisibleContinue() {
     if (!_agent) return;
 
+    // Guard 0: if the user aborted, don't drive a new prompt([]).
+    // This catches aborts that happened between agent_end firing and
+    // this async function actually executing (e.g. during backoff sleep
+    // or while waitForIdle was pending).
+    if (_userAborted) return;
+
     // Guard 1: mutex — if a previous continue is still in-flight, skip
     if (_continueInProgress) return;
     _continueInProgress = true;
@@ -383,6 +426,10 @@ export default function (pi: ExtensionAPI) {
       // finishRun() after agent_end listeners return).
       await _agent.waitForIdle();
 
+      // Re-check after waitForIdle: the user may have aborted while
+      // we were waiting for the agent to become idle.
+      if (_userAborted) return;
+
       try {
         // Await so _continueInProgress stays true for the full retry.
         // The session's continue() is blocked (monkey-patch) and the
@@ -395,6 +442,10 @@ export default function (pi: ExtensionAPI) {
       }
     } finally {
       _continueInProgress = false;
+      // Record completion time so the continue() monkey-patch can
+      // detect that an invisible continue just ran and avoid firing
+      // a duplicate prompt([]) (RC7: double continuation guard).
+      _lastInvisibleContinueTime = Date.now();
     }
   }
 }