@monotykamary/pi-retry 0.6.5 → 0.6.7

package/README.md

@@ -25,7 +25,7 @@ This extension automatically detects and retries **all** errors by default, with
 | HTTP 400/413 | **Indefinite** with capped backoff, NO compaction | Transient context overflow that might resolve |
 | Credit / payment errors | **Indefinite** with capped backoff | "Not Enough Credits", insufficient balance, 402 |
 | Connection errors | **Indefinite** with capped backoff | Network hiccups, connection drops, socket errors, stream exhaustion |
-| Max tokens (`stopReason: "length"`) | **Auto-continue** indefinitely (invisible — no prompt pollution) | Model hits output token limit mid-generation |
+| Max tokens (`stopReason: "length"`) | **Auto-continue** indefinitely with hidden continuation turns | Model hits output token limit mid-generation |
 
 ---
 
@@ -48,10 +48,10 @@ This extension provides **automatic** infinite retry with sensible exponential b
 **Features:**
 - **Catch-all retry** — Any `stopReason: "error"` is retried, regardless of error message
 - Automatic detection of 400/413, connection, credit, and stream exhaustion errors
-- **Auto-continuation** when the model hits its max output tokens (`stopReason: "length"`) — indefinite, no cap, **invisible** to the LLM
+- **Auto-continuation** when the model hits its max output tokens (`stopReason: "length"`) — indefinite, no cap, hidden from the TUI
 - **Indefinite retry** — Keeps retrying until success
 - Exponential backoff with cap: max 60s between retries
-- **ALL triggers are invisible** — custom messages with `display: false`, stripped by context handler (no TUI clutter, no conversation pollution)
+- **Hidden triggers** — provider-valid custom messages use `display: false`, so retries do not add TUI clutter
 - Manual controls via unified `/retry` command
 - Non-retryable errors are explicitly logged so you know why we didn't retry
 
@@ -124,7 +124,7 @@ Edit the constants at the top of `retry.ts`:
 const BASE_DELAY_MS = 2000;        // Start with 2 seconds
 const MAX_DELAY_MS = 60000;        // Cap at 60 seconds
 const BACKOFF_MULTIPLIER = 2;      // Double each time
-// Continuation is now invisible — no CONTINUATION_PROMPT needed
+// Continuations use a hidden provider-valid custom message
 ```
 
 ---
@@ -135,9 +135,10 @@ const BACKOFF_MULTIPLIER = 2;      // Double each time
 2. **Check for any error** — Examine the last assistant message for `stopReason === "error"`
 3. **Blacklist check** — Skip known permanent failures (invalid API key, model not found, etc.)
 4. **Categorize for messaging** — Classify into 400/413, credit, connection, or other for nice UI notifications
-5. **Retry or continue (both invisible)** — Wait (exponential backoff for errors), then trigger a new turn via `pi.sendMessage()` with `customType`, `display: false`, and `triggerTurn: true`
-6. **Context cleanup** — The `context` event strips all custom-type triggers before the LLM sees them (insurance against custom `convertToLlm` overrides)
-7. **Indefinite continuation** — Max_tokens auto-continues are uncapped; each continuation produces valid output and the model naturally terminates when done
+5. **Retry or continue with hidden turns** — Wait with exponential backoff, then trigger a provider-valid custom user turn via `pi.sendMessage()` with `display: false` and `triggerTurn: true`
+6. **Valid provider context** — Hidden retry and continuation messages remain in context so providers never receive a trailing assistant message
+7. **Indefinite continuation** — Max_tokens auto-continues are uncapped; repeated `length` stops keep producing continuation turns until the model terminates normally
+8. **Lifecycle exposure** — Emits `pi-retry:started`, `pi-retry:completed`, and `pi-retry:cancelled` on Pi's shared extension event bus with a matching `retryId`, allowing status integrations to suppress intermediate completion signals
 
 The pi's built-in `transform-messages` already strips aborted/errored assistant messages from the LLM context, so the model never sees the failed attempts.
 
@@ -160,7 +161,7 @@ These are explicitly **not** retried:
 ### Max Tokens (stopReason: "length")
 - The model hit its `max_tokens` / output token limit
 - The model's response was truncated mid-generation
-- Auto-continuation sends an invisible custom message — no visible "Continue" prompt in the conversation
+- Auto-continuation sends a provider-valid custom message hidden from the TUI
 
 ### 400/413 Errors
 - HTTP 400 Bad Request

package/package.json

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

@@ -21,6 +21,10 @@ import {
   CONTINUATION_CUSTOM_TYPE,
 } from "./src/index.js";
 
+const RETRY_STARTED_EVENT = "pi-retry:started";
+const RETRY_COMPLETED_EVENT = "pi-retry:completed";
+const RETRY_CANCELLED_EVENT = "pi-retry:cancelled";
+
 /**
  * Unified retry extension — retries EVERY error by default.
  *
@@ -35,12 +39,12 @@ 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 — hidden AgentSession turns are filtered before the LLM call
+ * - Retry triggers are hidden in the TUI and serialized as provider-valid user turns
  * - Unified manual controls via /retry command
  *
  * Continuation mechanism:
  *   - A hidden custom message starts or joins a canonical AgentSession turn
- *   - A context hook removes that marker before provider serialization
+ *   - The message remains in context as a provider-valid user turn
  *   - AgentSession remains authoritative for busy state and queued messages
  *
  * Retry loop design:
@@ -111,6 +115,7 @@ let _continueInProgress = false;
 let _continueGeneration: number | null = null;
 let _continueInputGeneration: number | null = null;
 let _inputGeneration = 0;
+let _retryLifecycleId = 0;
 
 // Session generation counter: incremented on every session_start.
 // The retry loop captures the current generation when it starts and exits
@@ -161,33 +166,26 @@ function removeErrorFromAgentState(): void {
   }
 }
 
-// Check if the agent's last message indicates a retryable error.
-function lastMessageIsRetryableError(): boolean {
-  if (!_agent) return false;
+type HiddenTurnKind = "retry" | "continue";
+
+function getHiddenTurnKind(): HiddenTurnKind | null {
+  if (!_agent) return null;
   const messages = _agent.state.messages;
   const lastMsg = messages[messages.length - 1];
-  return lastMsg?.role === 'assistant' && lastMsg.stopReason === 'error';
+  if (lastMsg?.role !== "assistant") return null;
+  if (lastMsg.stopReason === "error") return "retry";
+  if (lastMsg.stopReason === "length") return "continue";
+  return null;
+}
+
+function lastMessageIsRetryableError(): boolean {
+  return getHiddenTurnKind() === "retry";
 }
 
 export default function (pi: ExtensionAPI) {
 
-  const markRealPromptStart = () => {
+  pi.on("input", () => {
     _inputGeneration++;
-  };
-  pi.on("input", (event) => {
-    if (event.source === "interactive" || event.source === "rpc") {
-      markRealPromptStart();
-    }
-  });
-  pi.on("before_agent_start", markRealPromptStart);
-
-  pi.on("context", (event) => {
-    const messages = event.messages.filter((message: any) => !(
-      message.role === "custom" &&
-      (message.customType === RETRY_TRIGGER_CUSTOM_TYPE ||
-        message.customType === CONTINUATION_CUSTOM_TYPE)
-    ));
-    if (messages.length !== event.messages.length) return { messages };
   });
 
   // Reset retry counters on successful completion (not max_tokens, not error)
@@ -249,14 +247,14 @@ export default function (pi: ExtensionAPI) {
       _continueInputGeneration === _inputGeneration
     ) return;
 
-    // Check for max_tokens stop — auto-continue (invisible to LLM)
+    // Check for max_tokens stop — auto-continue with a hidden TUI message
     if (hasMaxTokensStop(lastAssistant) && !stateContinuation.getIsContinuing()) {
       stateContinuation.startContinuation();
       ctx.ui.notify(
         `Max tokens reached — auto-continuing (continuation ${stateContinuation.getCount()})...`,
         "info",
       );
-      void triggerInvisibleContinue();
+      void triggerInvisibleContinue("continue");
       stateContinuation.endContinuation();
       return;
     }
@@ -303,7 +301,7 @@ export default function (pi: ExtensionAPI) {
       state.startRetry(errorMsg);
       state.endRetry();
 
-      void triggerInvisibleContinue();
+      void triggerInvisibleContinue("retry");
       return;
     }
 
@@ -358,7 +356,7 @@ export default function (pi: ExtensionAPI) {
         status += "Max Tokens Continuation:\n";
         status += `  Continuations used: ${stateContinuation.getCount()}\n`;
         status += `  Is continuing: ${stateContinuation.getIsContinuing()}\n`;
-        status += `  Trigger: hidden AgentSession turn (filtered before provider call)\n\n`;
+        status += `  Trigger: hidden provider-valid AgentSession turn\n\n`;
 
         // Config
         status += "Configuration:\n";
@@ -409,7 +407,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");
-        void triggerInvisibleContinue();
+        void triggerInvisibleContinue("continue");
         return;
       }
 
@@ -428,21 +426,21 @@ export default function (pi: ExtensionAPI) {
       if (has400or413Error(lastAssistant)) {
         ctx.ui.notify("Manually retrying 400/413 error...", "info");
         state400.reset();
-        void triggerInvisibleContinue();
+        void triggerInvisibleContinue("retry");
         return;
       }
 
       if (hasCreditError(lastAssistant)) {
         ctx.ui.notify("Manually retrying credit error...", "info");
         stateCredit.reset();
-        void triggerInvisibleContinue();
+        void triggerInvisibleContinue("retry");
         return;
       }
 
       if (hasConnectionError(lastAssistant)) {
         ctx.ui.notify("Manually retrying connection error...", "info");
         stateConnection.reset();
-        void triggerInvisibleContinue();
+        void triggerInvisibleContinue("retry");
         return;
       }
 
@@ -450,7 +448,7 @@ export default function (pi: ExtensionAPI) {
       if (hasRetryableError(lastAssistant)) {
         ctx.ui.notify("Manually retrying error...", "info");
         stateOther.reset();
-        void triggerInvisibleContinue();
+        void triggerInvisibleContinue("retry");
         return;
       }
 
@@ -500,9 +498,10 @@ export default function (pi: ExtensionAPI) {
   //
   // Unlike the original one-shot design, this function loops. After each
   // hidden AgentSession turn it checks the result:
-  //   - Success (stopReason !== "error"): loop exits, agent is done.
-  //   - Error (stopReason === "error"): sleep with backoff, then retry.
-  //   - User abort (stopReason "aborted"): loop exits immediately.
+  //   - Success: loop exits when the stop reason is neither error nor length.
+  //   - Error: sleep with backoff, then retry the request.
+  //   - Length: sleep with backoff, then continue the response.
+  //   - User abort: loop exits immediately.
   //
   // The backoff sleep happens AFTER the hidden turn settles and processEvents
   // has settled, so it does NOT block the agent. The agent is idle during
@@ -511,7 +510,7 @@ export default function (pi: ExtensionAPI) {
   // Before each retry, the error assistant message is removed from
   // agent.state.messages so the LLM receives a clean context (same
   // technique as the built-in retry's _prepareRetry).
-  async function triggerInvisibleContinue() {
+  async function triggerInvisibleContinue(initialKind: HiddenTurnKind) {
     if (!_agent) return;
 
     // Guard: if the user aborted, do not queue another retry turn.
@@ -520,6 +519,9 @@ export default function (pi: ExtensionAPI) {
     // Guard: mutex — if a previous continue is still in-flight, skip
     if (_continueInProgress) return;
     _continueInProgress = true;
+    const retryLifecycleId = ++_retryLifecycleId;
+    let didRetryComplete = false;
+    pi.events.emit(RETRY_STARTED_EVENT, { retryId: retryLifecycleId });
 
     // Capture the current session generation. If /new fires while we're
     // looping, _sessionGeneration will increment and the loop will exit.
@@ -542,6 +544,7 @@ export default function (pi: ExtensionAPI) {
       ) return;
 
       let attempt = 0;
+      let hiddenTurnKind: HiddenTurnKind | null = initialKind;
 
       // Loop until success, abort, or session change.
       while (true) {
@@ -552,8 +555,12 @@ export default function (pi: ExtensionAPI) {
         ) return;
 
         // Preserve the trigger kind before removing a trailing error from
-        // live state. The error remains in the session journal for history.
-        const isErrorRetry = lastMessageIsRetryableError();
+        // live state. Length-stopped output stays in context so the model can
+        // continue from it; error messages remain only in the session journal.
+        if (!hiddenTurnKind) {
+          didRetryComplete = true;
+          return;
+        }
         removeErrorFromAgentState();
 
         attempt++;
@@ -576,10 +583,12 @@ export default function (pi: ExtensionAPI) {
         try {
           pi.sendMessage(
             {
-              customType: isErrorRetry
+              customType: hiddenTurnKind === "retry"
                 ? RETRY_TRIGGER_CUSTOM_TYPE
                 : CONTINUATION_CUSTOM_TYPE,
-              content: [],
+              content: hiddenTurnKind === "retry"
+                ? "Retry the previous request."
+                : "Continue exactly where you left off without repeating content.",
               display: false,
               details: undefined,
             },
@@ -603,17 +612,20 @@ export default function (pi: ExtensionAPI) {
           _inputGeneration !== myInputGeneration
         ) return;
 
-        // The hidden AgentSession turn completed. Check the result.
-        if (!lastMessageIsRetryableError()) {
-          // Success or non-error terminal state — exit the loop.
+        // The hidden AgentSession turn completed. Both errors and output
+        // length stops need another turn; all other terminal states are done.
+        hiddenTurnKind = getHiddenTurnKind();
+        if (!hiddenTurnKind) {
+          didRetryComplete = true;
           return;
         }
-
-        // Error again — loop back for another attempt.
       }
     } finally {
       // Release the mutex only if this loop still owns it.
       if (_continueGeneration === myGeneration) {
+        pi.events.emit(didRetryComplete ? RETRY_COMPLETED_EVENT : RETRY_CANCELLED_EVENT, {
+          retryId: retryLifecycleId,
+        });
         _continueInProgress = false;
         _continueGeneration = null;
         _continueInputGeneration = null;