@monotykamary/pi-retry 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-retry",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "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.1",
-    "@earendil-works/pi-coding-agent": "0.79.4",
+    "@earendil-works/pi-agent-core": "^0.79.8",
+    "@earendil-works/pi-coding-agent": "^0.79.8",
     "@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,
@@ -73,6 +74,10 @@ Agent.prototype.subscribe = function (this: Agent, ...args: any[]) {
 // with our _continueInProgress mutex AND can convert the "Cannot continue
 // from assistant" error into a prompt([]) call when the agent was mid-task
 // (compaction, toolUse, length — but NOT error, which the loop handles).
+//
+// Note (pi 0.79+): Agent.continue() now drains queued steering/follow-up
+// messages before throwing, so this throw path only fires when there are
+// genuinely no queued messages — the prompt([]) fallback is still correct.
 const _origContinue = Agent.prototype.continue as (this: Agent) => Promise<void>;
 Agent.prototype.continue = function (this: Agent) {
   const self = this;
@@ -286,6 +291,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";
@@ -425,6 +454,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");

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 ──
 
 /**