@monotykamary/pi-retry 0.7.2 → 0.8.1

package/README.md

@@ -27,6 +27,7 @@ This extension automatically detects and retries **all** errors by default, with
 | **Quota / session-limit / budget exhaustion** | **Not retried** — notify + stop | "You've hit your limit", `insufficient_quota`, "out of budget", suspended accounts |
 | Connection errors | **Indefinite** with capped backoff | Network hiccups, connection drops, socket errors, stream exhaustion |
 | Max tokens (`stopReason: "length"`) | **Auto-continue** indefinitely with hidden continuation turns | Model hits output token limit mid-generation |
+| Empty / think-only stop (`stopReason: "stop"` with no text or tool calls) | **Nudge once** with a hidden continuation, then give up | Model ends its turn with no usable output (Anthropic empty responses with end_turn, thinking-only turns) |
 
 ---
 
@@ -140,6 +141,7 @@ const BACKOFF_MULTIPLIER = 2;      // Double each time
 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. **Empty-stop recovery** — A `stop` turn with no usable output (only thinking, or nothing at all) gets exactly one hidden "nudge" continuation, then gives up. Matches Anthropic's documented "empty responses with `end_turn`" remedy (continuation prompt in a new user message) — retrying an empty response in place doesn't help because the model has already decided it's done.
 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-retry",
-  "version": "0.7.2",
+  "version": "0.8.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",
@@ -38,9 +38,9 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.84.2",
-    "@earendil-works/pi-coding-agent": "^0.84.2",
-    "@earendil-works/pi-tui": "^0.84.2",
+    "@earendil-works/pi-agent-core": "^0.84.3",
+    "@earendil-works/pi-coding-agent": "^0.84.3",
+    "@earendil-works/pi-tui": "^0.84.3",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",
     "knip": "6.14.1",

package/retry.ts

@@ -11,6 +11,7 @@ import {
   isSilencedError,
   hasQuotaExhaustedError,
   hasMaxTokensStop,
+  hasEmptyStop,
   isContextOverflowError,
   isAssistantMessage,
   getLastAssistantMessage,
@@ -105,6 +106,14 @@ const stateOther = new RetryState();
 // Max_tokens continuation state (indefinite — no cap needed)
 const stateContinuation = new ContinuationState();
 
+// Empty/think-only stop continuation state — BOUNDED by design: the model
+// decided to end its turn with no usable output (zero text, zero tool
+// calls; Anthropic's documented "empty responses with end_turn"/reasoning
+// budget exhaustion). It gets ONE nudge, then we give up rather than
+// burning tokens looping on a model that has decided it is done.
+const stateEmptyStop = new ContinuationState();
+const MAX_EMPTY_CONTINUATIONS = 1;
+
 // Abort flag: set when Pi's active signal is aborted or turn_end reports
 // stopReason "aborted", cleared on session_start and fresh user activity.
 // Prevents triggerInvisibleContinue() from starting a hidden retry turn after
@@ -170,7 +179,7 @@ function removeErrorFromAgentState(): void {
   }
 }
 
-type HiddenTurnKind = "retry" | "continue";
+type HiddenTurnKind = "retry" | "continue" | "empty";
 
 function getHiddenTurnKind(): HiddenTurnKind | null {
   if (!_agent) return null;
@@ -179,6 +188,7 @@ function getHiddenTurnKind(): HiddenTurnKind | null {
   if (lastMsg?.role !== "assistant") return null;
   if (lastMsg.stopReason === "error") return "retry";
   if (lastMsg.stopReason === "length") return "continue";
+  if (hasEmptyStop(lastMsg)) return "empty";
   return null;
 }
 
@@ -210,6 +220,7 @@ export default function (pi: ExtensionAPI) {
       stateConnection.reset();
       stateOther.reset();
       stateContinuation.endContinuation();
+      stateEmptyStop.endContinuation();
       // Signal to any in-flight triggerInvisibleContinue or pending retry
       // that the user has cancelled — do not queue another retry turn.
       _userAborted = true;
@@ -223,6 +234,7 @@ export default function (pi: ExtensionAPI) {
         stateConnection.succeed();
         stateOther.succeed();
         stateContinuation.complete();
+        stateEmptyStop.complete();
         // Clear abort flag — this is a fresh successful turn, so any
         // previous abort is stale and shouldn't block future retries.
         _userAborted = false;
@@ -278,6 +290,27 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
+    // Empty / think-only stop - the model ended its turn with NO usable
+    // output (zero text blocks, zero tool calls; only thinking or nothing).
+    // Anthropic documents these as "empty responses with end_turn" - the
+    // model decided the turn is complete. Not an error, but also not a
+    // usable turn: without this, the agent just goes silent.
+    //
+    // Remedy (per Anthropic docs and CLIProxyAPI 4886 measurements): one
+    // continuation prompt in a NEW user message. Bounded on purpose - a
+    // model that returns empty once tends to be done; see
+    // MAX_EMPTY_CONTINUATIONS below.
+    if (hasEmptyStop(lastAssistant) && !stateEmptyStop.getIsContinuing()) {
+      stateEmptyStop.startContinuation();
+      ctx.ui.notify(
+        `Empty response - nudging once to produce output (continuation ${stateEmptyStop.getCount()})...`,
+        "info",
+      );
+      void triggerInvisibleContinue("empty");
+      stateEmptyStop.endContinuation();
+      return;
+    }
+
     // Context overflow: defer to compaction. Do NOT retry here.
     //
     // Retrying the same oversized context before compaction would produce an
@@ -382,6 +415,12 @@ export default function (pi: ExtensionAPI) {
         status += `  Is continuing: ${stateContinuation.getIsContinuing()}\n`;
         status += `  Trigger: hidden provider-valid AgentSession turn\n\n`;
 
+        // Empty-stop continuation state
+        status += "Empty/Think-only Stop Continuation:\n";
+        status += `  Continuations used: ${stateEmptyStop.getCount()}\n`;
+        status += `  Is continuing: ${stateEmptyStop.getIsContinuing()}\n`;
+        status += `  Cap: ${MAX_EMPTY_CONTINUATIONS} nudge(s), then give up\n\n`;
+
         // Config
         status += "Configuration:\n";
         status += `  Base delay: 2000ms\n`;
@@ -410,6 +449,7 @@ export default function (pi: ExtensionAPI) {
         stateConnection.reset();
         stateOther.reset();
         stateContinuation.reset();
+        stateEmptyStop.reset();
         _userAborted = false;
         ctx.ui.notify("All retry counters reset", "info");
         return;
@@ -435,6 +475,13 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
+      // Empty / think-only stop — nudge once
+      if (hasEmptyStop(lastAssistant)) {
+        ctx.ui.notify("Empty response — nudging once...", "info");
+        void triggerInvisibleContinue("empty");
+        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.
@@ -506,6 +553,7 @@ export default function (pi: ExtensionAPI) {
     stateConnection.reset();
     stateOther.reset();
     stateContinuation.reset();
+    stateEmptyStop.reset();
     // Do NOT reset _continueInProgress here — the in-flight loop's
     // finally block releases its owner token. Resetting it here could allow
     // a second loop to start before the old one has settled.
@@ -586,6 +634,9 @@ export default function (pi: ExtensionAPI) {
 
       let attempt = 0;
       let hiddenTurnKind: HiddenTurnKind | null = initialKind;
+      // Empty-stop nudges are bounded: MAX_EMPTY_CONTINUATIONS total
+      // continuation requests, then we give up (the model decided it is done).
+      let emptyNudges = 0;
 
       // Loop until success, abort, or session change.
       while (true) {
@@ -604,6 +655,20 @@ export default function (pi: ExtensionAPI) {
         }
         removeErrorFromAgentState();
 
+        // Empty-stop cap: a model that produced no usable output and answers
+        // the nudge with another empty turn is decided, not stalled. Stop
+        // after MAX_EMPTY_CONTINUATIONS rather than looping forever.
+        if (hiddenTurnKind === "empty") {
+          if (emptyNudges >= MAX_EMPTY_CONTINUATIONS) {
+            _notifyFn?.(
+              `Empty response after ${emptyNudges} continuation(s) - giving up (model keeps ending the turn with no output).`,
+              "warning",
+            );
+            return;
+          }
+          emptyNudges++;
+        }
+
         attempt++;
         const delay = calculateDelay(attempt);
 
@@ -629,7 +694,9 @@ export default function (pi: ExtensionAPI) {
                 : CONTINUATION_CUSTOM_TYPE,
               content: hiddenTurnKind === "retry"
                 ? "Retry the previous request."
-                : "Continue exactly where you left off without repeating content.",
+                : hiddenTurnKind === "empty"
+                  ? "Your previous turn contained only thinking and no answer or text. Continue now and produce the actual response, using tools if needed."
+                  : "Continue exactly where you left off without repeating content.",
               display: false,
               details: undefined,
             },

package/src/error-patterns.ts

@@ -322,5 +322,39 @@ export function hasMaxTokensStop(message: AgentMessage): boolean {
   return message.stopReason === "length";
 }
 
+// ── Empty / think-only stop (not an error — continuation) ──
+
+function getContentBlocks(message: AgentMessage): unknown[] {
+  const content = (message as { content?: unknown }).content;
+  return Array.isArray(content) ? content : [];
+}
+
+/**
+ * Returns true for an assistant message whose turn ended without any
+ * USABLE output: stopReason "stop" with only empty content — zero blocks
+ * (Anthropic's documented empty responses with end_turn) or only reasoning
+ * blocks (a reasoning model spent its output budget on thinking and never
+ * produced text/tool calls — pi#6963 / kimi-cli think-only class).
+ *
+ * "Usable" = a non-empty text block or a toolCall block. Thinking, images,
+ * and blank text do not count. This deliberately mirrors Anthropic's
+ * "Empty responses..." do not continue the loop on these, and does NOT
+ * flag a legitimately text-only final answer.
+ */
+export function hasEmptyStop(message: AgentMessage): boolean {
+  if (!isAssistantMessage(message)) return false;
+  if (message.stopReason !== "stop") return false;
+  const hasUsable = getContentBlocks(message).some((block) => {
+    if (!block || typeof block !== "object") return false;
+    const candidate = block as { type?: unknown; text?: unknown };
+    if (candidate.type === "toolCall") return true;
+    if (candidate.type === "text") {
+      return typeof candidate.text === "string" && candidate.text.trim().length > 0;
+    }
+    return false;
+  });
+  return !hasUsable;
+}
+
 // Re-export getLastAssistantMessage for convenience
 export { getLastAssistantMessage } from './retry-logic.js';