@monotykamary/pi-retry 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-retry",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "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

@@ -1,7 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Agent } from "@earendil-works/pi-agent-core";
 import {
-  RETRY_TRIGGER_CUSTOM_TYPE,
-  CONTINUATION_CUSTOM_TYPE,
   has400or413Error,
   hasCreditError,
   hasConnectionError,
@@ -31,16 +30,27 @@ import {
  * - Automatic detection and retry for ALL errors (catch-all)
  * - Indefinite retry with exponential backoff (capped at 60s)
  * - Auto-continuation when model hits max output tokens (stopReason "length")
- * - ALL triggers are invisible — custom messages with display:false, stripped by context handler
+ * - ALL triggers are invisible — agent.prompt([]) resumes the loop with no new message
  * - Unified manual controls via /retry command
  *
- * Silent continue trick (ported from pi-invisible-continue):
- *   - sendMessage() with customType + display:false + triggerTurn:true
- *   - pi's default convertToLlm filters custom-role messages → LLM never sees them
- *   - context event handler strips them as insurance against custom convertToLlm overrides
- *   - No user-visible "Continue" message pollution in the conversation
+ * Invisibility mechanism:
+ *   - Agent.prototype.subscribe monkey-patch captures the Agent instance
+ *   - agent.prompt([]) starts a fresh agent loop with an empty prompt array
+ *   - No message injected into context — LLM sees the exact same message list
+ *   - No convertToLlm involvement, no filter needed, no session artifact
  */
 
+// Capture the live Agent instance when AgentSession subscribes to it.
+// subscribe() is called during AgentSession construction — fires on both
+// fresh sessions and session resumes.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _agent: Agent | null = null;
+const _origSubscribe = Agent.prototype.subscribe as (...args: any[]) => any;
+Agent.prototype.subscribe = function (this: Agent, ...args: any[]) {
+  _agent = this;
+  return _origSubscribe.apply(this, args);
+};
+
 // Per-category retry state (for diagnostics / messaging)
 const state400 = new RetryState();
 const stateCredit = new RetryState();
@@ -50,6 +60,12 @@ const stateOther = new RetryState();
 // Max_tokens continuation state (indefinite — no cap needed)
 const stateContinuation = new ContinuationState();
 
+// 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;
+
 // Sleep helper
 function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
@@ -93,14 +109,15 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
-    // Check for max_tokens stop — auto-continue (silent, invisible to LLM)
+    // Check for max_tokens stop — auto-continue (invisible to LLM)
     if (hasMaxTokensStop(lastAssistant) && !stateContinuation.getIsContinuing()) {
       stateContinuation.startContinuation();
       ctx.ui.notify(
         `Max tokens reached — auto-continuing (continuation ${stateContinuation.getCount()})...`,
         "info",
       );
-      triggerContinuation(pi);
+      // Must NOT await — see triggerInvisibleContinue() for explanation
+      void triggerInvisibleContinue();
       stateContinuation.endContinuation();
       return;
     }
@@ -133,7 +150,8 @@ export default function (pi: ExtensionAPI) {
       const delay = calculateDelay(state.getAttempt());
 
       await sleep(delay);
-      triggerRetry(pi);
+      // Must NOT await — see triggerInvisibleContinue() for explanation
+      void triggerInvisibleContinue();
       state.endRetry();
       return;
     }
@@ -147,23 +165,6 @@ export default function (pi: ExtensionAPI) {
 
 
 
-  // Strip hidden retry/continuation markers from context before each LLM call.
-  // This is insurance — convertToLlm already filters custom roles, but a
-  // custom convertToLlm override could leak them.  Clean proactively.
-  pi.on("context", async (event) => {
-    const cleaned = event.messages.filter(
-      (msg: any) =>
-        !(
-          msg.role === "custom" &&
-          (msg.customType === RETRY_TRIGGER_CUSTOM_TYPE ||
-            msg.customType === CONTINUATION_CUSTOM_TYPE)
-        ),
-    );
-    if (cleaned.length !== event.messages.length) {
-      return { messages: cleaned };
-    }
-  });
-
   // Unified /retry command with subcommands
   pi.registerCommand("retry", {
     description: "Unified retry controls: /retry (manual trigger), /retry status (diagnostics), /retry reset (clear state)",
@@ -205,14 +206,14 @@ export default function (pi: ExtensionAPI) {
         status += "Max Tokens Continuation:\n";
         status += `  Continuations used: ${stateContinuation.getCount()}\n`;
         status += `  Is continuing: ${stateContinuation.getIsContinuing()}\n`;
-        status += `  Trigger: invisible (custom message, LLM never sees a prompt)\n\n`;
+        status += `  Trigger: invisible (agent.prompt([]), LLM never sees a prompt)\n\n`;
         
         // Config
         status += "Configuration:\n";
         status += `  Base delay: 2000ms\n`;
         status += `  Max delay: 60000ms\n`;
         status += `  Backoff multiplier: 2\n`;
-        status += `  Continuation: invisible custom message\n\n`;
+        status += `  Continuation: invisible (agent.prompt([]))\n\n`;
         
         // Last assistant info
         if (lastAssistant && isAssistantMessage(lastAssistant)) {
@@ -251,7 +252,7 @@ export default function (pi: ExtensionAPI) {
       // Auto-detect: max_tokens continuation takes priority
       if (hasMaxTokensStop(lastAssistant)) {
         ctx.ui.notify("Manually continuing after max_tokens...", "info");
-        triggerContinuation(pi);
+        void triggerInvisibleContinue();
         return;
       }
 
@@ -259,21 +260,21 @@ export default function (pi: ExtensionAPI) {
       if (has400or413Error(lastAssistant)) {
         ctx.ui.notify("Manually retrying 400/413 error...", "info");
         state400.reset();
-        triggerRetry(pi);
+        void triggerInvisibleContinue();
         return;
       }
 
       if (hasCreditError(lastAssistant)) {
         ctx.ui.notify("Manually retrying credit error...", "info");
         stateCredit.reset();
-        triggerRetry(pi);
+        void triggerInvisibleContinue();
         return;
       }
 
       if (hasConnectionError(lastAssistant)) {
         ctx.ui.notify("Manually retrying connection error...", "info");
         stateConnection.reset();
-        triggerRetry(pi);
+        void triggerInvisibleContinue();
         return;
       }
 
@@ -281,7 +282,7 @@ export default function (pi: ExtensionAPI) {
       if (hasRetryableError(lastAssistant)) {
         ctx.ui.notify("Manually retrying error...", "info");
         stateOther.reset();
-        triggerRetry(pi);
+        void triggerInvisibleContinue();
         return;
       }
 
@@ -297,31 +298,46 @@ export default function (pi: ExtensionAPI) {
     stateConnection.reset();
     stateOther.reset();
     stateContinuation.reset();
+    _continueInProgress = false;
   });
 
-  // Helper: send the hidden retry trigger
-  function triggerRetry(pi: ExtensionAPI) {
-    pi.sendMessage(
-      {
-        customType: RETRY_TRIGGER_CUSTOM_TYPE,
-        content: "",
-        display: false,
-        details: {},
-      },
-      { triggerTurn: true },
-    );
-  }
-
-  // Helper: send the hidden continuation trigger (silent — LLM never sees a prompt)
-  function triggerContinuation(pi: ExtensionAPI) {
-    pi.sendMessage(
-      {
-        customType: CONTINUATION_CUSTOM_TYPE,
-        content: "",
-        display: false,
-        details: {},
-      },
-      { triggerTurn: true },
-    );
+  // Resume the agent loop invisibly — no message injected into context.
+  // The LLM sees the exact same message list it had before.
+  //
+  // IMPORTANT: We must wait for the agent to become idle before calling
+  // prompt().  The agent_end event fires while the active run is still
+  // set (it's cleared in the finally block, after all listeners settle).
+  // Calling prompt() inside an agent_end listener would otherwise throw
+  // "Agent is already processing a prompt" because activeRun is truthy.
+  //
+  // GUARDS (three layers):
+  //   1. _continueInProgress mutex — prevents concurrent calls from racing
+  //   2. isStreaming pre-flight — detects user-initiated runs before prompt()
+  //   3. try/catch — final safety net, swallows the error gracefully
+  async function triggerInvisibleContinue() {
+    if (!_agent) return;
+
+    // Guard 1: mutex — if a previous continue is still in-flight, skip
+    if (_continueInProgress) return;
+    _continueInProgress = true;
+
+    try {
+      await _agent.waitForIdle();
+
+      // Guard 2: pre-flight — the user may have sent a message while we
+      // waited for idle.  agent.state.isStreaming is authoritative (read
+      // directly from the activeRun field, no TOCTOU beyond the next line).
+      if (_agent.state.isStreaming) return;
+
+      try {
+        _agent.prompt([]);
+      } catch {
+        // Guard 3: catch the "already processing" error as a last resort.
+        // This handles the remaining microtask TOCTOU gap between the
+        // isStreaming check and prompt() acquiring the lock.
+      }
+    } finally {
+      _continueInProgress = false;
+    }
   }
 }

package/src/error-patterns.ts

@@ -9,17 +9,6 @@
 
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 
-// Custom message types for invisible triggers.
-// These are sent with role="custom" and display=false, so pi's default
-// convertToLlm filters them out.  The context event handler also strips
-// them as insurance.
-
-/** Custom type used for the invisible error-retry trigger. */
-export const RETRY_TRIGGER_CUSTOM_TYPE = "__retry_trigger";
-
-/** Custom type used for the invisible max_tokens continuation trigger. */
-export const CONTINUATION_CUSTOM_TYPE = "__retry_continuation";
-
 // ── Specific pattern groups (used for categorisation / messaging) ──
 
 const ERROR_400_413_PATTERNS = [