@monotykamary/pi-retry 0.6.2 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-retry",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Extension suite for pi coding agent that handles 400/413 errors and connection errors with automatic retry",
   "type": "module",
   "author": "Tom X Nguyen",
@@ -32,16 +32,9 @@
     "src/",
     "README.md"
   ],
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint:dead": "knip --no-gitignore"
-  },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.79.8",
-    "@earendil-works/pi-coding-agent": "^0.79.8",
+    "@earendil-works/pi-agent-core": "^0.80.7",
+    "@earendil-works/pi-coding-agent": "^0.80.7",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",
     "knip": "6.14.1",
@@ -55,5 +48,12 @@
   },
   "overrides": {
     "brace-expansion": "5.0.6"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint:dead": "knip --no-gitignore"
   }
-}
+}

package/retry.ts

@@ -9,6 +9,7 @@ import {
   isNonRetryableError,
   isSilencedError,
   hasMaxTokensStop,
+  isContextOverflowError,
   isAssistantMessage,
   getLastAssistantMessage,
   calculateDelay,
@@ -167,6 +168,8 @@ let _userAborted = false;
 // automatic retry) race through waitForIdle() and both call prompt([]),
 // producing "Agent is already processing".
 let _continueInProgress = false;
+// Session generation that owns the retry mutex and its Escape handler.
+let _continueGeneration: number | null = null;
 
 // Timestamp of the last completed triggerInvisibleContinue().
 // Used by the continue() monkey-patch to avoid double continuation when
@@ -178,6 +181,8 @@ let _lastInvisibleContinueTime = 0;
 // when it changes — this handles /new and other session switches.
 let _sessionGeneration = 0;
 
+let _terminalInputUnsubscribe: (() => void) | null = null;
+
 // Interruptible sleep: polls _userAborted and _sessionGeneration every
 // 100ms.  Returns true if interrupted (abort or session change), false if
 // the full delay elapsed normally.
@@ -290,6 +295,30 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
+    // Context overflow: defer to compaction. Do NOT retry here.
+    //
+    // triggerInvisibleContinue() calls agent.prompt([]) directly on the core
+    // Agent, bypassing AgentSession._handlePostAgentRun → _checkCompaction, so
+    // a pi-retry retry loop gets NO compaction. Retrying an overflow would
+    // re-send the same oversized context → overflow again → infinite loop
+    // (pi-retry's error loop is uncapped). Meanwhile pi-retry's _continueInProgress
+    // mutex would block pi-core's own compaction-retry (agent.continue()), so
+    // pi-core never gets to compact either.
+    //
+    // Instead, return without firing triggerInvisibleContinue. pi-core's
+    // _checkCompaction (which runs in _handlePostAgentRun regardless of
+    // extensions) detects the same overflow, compacts (statically via pi-vcc
+    // when installed), and retries once via agent.continue() with the reduced
+    // context. _continueInProgress stays false, so pi-core's continue is
+    // unblocked.
+    if (isContextOverflowError(lastAssistant)) {
+      ctx.ui.notify(
+        "Context overflow — deferring to compaction (auto-retry after compact).",
+        "info",
+      );
+      return;
+    }
+
     // Catch-all: retry ANY error except known permanent failures
     if (hasRetryableError(lastAssistant)) {
       const errorMsg = lastAssistant.errorMessage || "Unknown error";
@@ -429,6 +458,17 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
+      // Context overflow: don't retry in place — reducing context is required.
+      // Compaction (pi-vcc / /compact) handles it and auto-retries. Retrying
+      // without compaction loops forever on a genuinely oversized payload.
+      if (isContextOverflowError(lastAssistant)) {
+        ctx.ui.notify(
+          "Context overflow — use /compact (or /pi-vcc) to reduce context. Compaction auto-retries.",
+          "info",
+        );
+        return;
+      }
+
       // Auto-detect error type and trigger appropriate retry
       if (has400or413Error(lastAssistant)) {
         ctx.ui.notify("Manually retrying 400/413 error...", "info");
@@ -465,7 +505,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   // Initialize
-  pi.on("session_start", async () => {
+  pi.on("session_start", async (_event, ctx) => {
     // Bump the generation counter so any in-flight retry loop from a
     // previous session exits on its next checkpoint (within 100ms during
     // backoff sleep, or immediately after prompt([]) returns).
@@ -477,11 +517,29 @@ export default function (pi: ExtensionAPI) {
     stateOther.reset();
     stateContinuation.reset();
     // Do NOT reset _continueInProgress here — the in-flight loop's
-    // finally block handles it conditionally (only if the generation
-    // hasn't changed since the loop started).  Resetting it here would
-    // break the mutex invariant and could allow a second loop to start.
+    // finally block releases its owner token. Resetting it here could allow
+    // a second loop to start before the old one has settled.
     _lastInvisibleContinueTime = 0;
     _userAborted = false;
+
+    _terminalInputUnsubscribe?.();
+    _terminalInputUnsubscribe = null;
+
+    if (ctx.mode === "tui") {
+      _terminalInputUnsubscribe = ctx.ui.onTerminalInput(data => {
+        if (
+          data !== "\x1b" ||
+          !_continueInProgress ||
+          _continueGeneration !== _sessionGeneration
+        ) {
+          return undefined;
+        }
+
+        _userAborted = true;
+        ctx.abort();
+        return { consume: true };
+      });
+    }
   });
 
   // Retry loop driver — the core of pi-retry.
@@ -512,6 +570,7 @@ export default function (pi: ExtensionAPI) {
     // Capture the current session generation. If /new fires while we're
     // looping, _sessionGeneration will increment and the loop will exit.
     const myGeneration = _sessionGeneration;
+    _continueGeneration = myGeneration;
 
     try {
       // Wait for the current run to finish (activeRun resolves in
@@ -566,11 +625,10 @@ export default function (pi: ExtensionAPI) {
         // Error again — loop back for another attempt.
       }
     } finally {
-      // Only reset the mutex if the session hasn't changed since we
-      // started.  If /new fired, a new retry loop may already own the
-      // mutex — resetting it here would clobber that.
-      if (_sessionGeneration === myGeneration) {
+      // Release the mutex only if this loop still owns it.
+      if (_continueGeneration === myGeneration) {
         _continueInProgress = false;
+        _continueGeneration = null;
       }
       _lastInvisibleContinueTime = Date.now();
     }

package/src/error-patterns.ts

@@ -64,6 +64,51 @@ const BUILTIN_HANDLED_PATTERNS = [
   /retry\s*delay/i,
 ];
 
+// Context-overflow error patterns. Mirrors pi-core's OVERFLOW_PATTERNS in
+// @earendil-works/pi-ai/dist/utils/overflow.js so that pi-retry defers to
+// compaction exactly when pi-core's _checkCompaction will detect overflow and
+// compact + retry. kept in sync manually — pi-ai is not a direct dependency.
+//
+// Why these are NOT retried by pi-retry: retrying an overflow via prompt([])
+// re-sends the same oversized context, so it overflows again → infinite loop
+// (pi-retry's loop is uncapped for errors). pi-core instead compacts and
+// retries once via agent.continue(); with static compaction (pi-vcc) that
+// reliably reduces context, so the single retry succeeds.
+const OVERFLOW_ERROR_PATTERNS = [
+  /prompt is too long/i,
+  /request_too_large/i,
+  /input is too long for requested model/i,
+  /exceeds the context window/i,
+  /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+  /input token count.*exceeds the maximum/i,
+  /maximum prompt length is \d+/i,
+  /reduce the length of the messages/i,
+  /maximum context length is \d+ tokens/i,
+  /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+  /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+  /exceeds the limit of \d+/i,
+  /exceeds the available context size/i,
+  /greater than the context length/i,
+  /context window exceeds limit/i,
+  /exceeded model token limit/i,
+  /too large for model with \d+ maximum context length/i,
+  /model_context_window_exceeded/i,
+  /prompt too long; exceeded (?:max )?context length/i,
+  /context[_ ]length[_ ]exceeded/i,
+  /too many tokens/i,
+  /token limit exceeded/i,
+  /^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i,
+];
+
+// Patterns that look like overflow but are actually rate limiting / throttling.
+// Mirrors pi-core's NON_OVERFLOW_PATTERNS. Excluded from overflow detection so
+// throttling errors are still retried (they are not context-size problems).
+const NON_OVERFLOW_PATTERNS = [
+  /^(Throttling error|Service unavailable):/i,
+  /rate limit/i,
+  /too many requests/i,
+];
+
 // ── Blacklist: errors that are truly permanent and should NOT be retried ──
 
 const NON_RETRYABLE_PATTERNS = [
@@ -109,6 +154,24 @@ export function hasConnectionError(message: AgentMessage): boolean {
   return CONNECTION_ERROR_PATTERNS.some(p => p.test(message.errorMessage!));
 }
 
+/**
+ * Returns true for an error assistant message whose errorMessage indicates a
+ * context-overflow (input exceeded the model's context window).
+ *
+ * Mirrors pi-core's isContextOverflow Case 1 (error-message patterns). The
+ * silent-overflow cases (stopReason "stop"/"length") are not errors and are
+ * never seen here — pi-core handles those in _checkCompaction directly.
+ *
+ * Callers should treat a true result as "defer to compaction, do NOT retry" —
+ * see OVERFLOW_ERROR_PATTERNS for rationale.
+ */
+export function isContextOverflowError(message: AgentMessage): boolean {
+  if (!isAssistantMessage(message)) return false;
+  if (message.stopReason !== "error" || !message.errorMessage) return false;
+  if (NON_OVERFLOW_PATTERNS.some(p => p.test(message.errorMessage!))) return false;
+  return OVERFLOW_ERROR_PATTERNS.some(p => p.test(message.errorMessage!));
+}
+
 // ── Universal retry check ──
 
 /**