@monotykamary/pi-retry 0.7.1 → 0.8.0

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.
@@ -162,9 +164,10 @@ These are explicitly **not** retried:
 
 ### Non-Retryable (Quota / Session Limit / Budget)
 Exhausted quotas, session limits, and budgets are auto-detected and stop the retry loop (with an explanatory notification), because retrying is pointless until you act or the reset window passes:
-- **Usage / session limits with reset windows** — "You've hit your limit · resets …" and "5-hour limit reached" (Claude Code), "You've hit your usage limit" / "You've exceeded your usage limit" (Codex)
+- **Usage / session limits with reset windows** — "You've hit your limit · resets …" and "5-hour limit reached" (Claude Code), "You've hit your usage limit" / "You've exceeded your usage limit" (Codex), "You have hit your ChatGPT usage limit (plus plan)" (ChatGPT subscription caps via the Codex backend, also `usage_limit_reached`)
 - **Plan / billing quotas** — OpenAI `insufficient_quota`, "You exceeded your current quota, please check your plan and billing details" (OpenAI, Gemini — reached only after pi's built-in 429 retry gives up)
-- **Hard allotments** — OpenRouter `free-models-per-day`, Alibaba "Allocated quota exceeded" (`Throttling.AllocationQuota`), GitHub Copilot "premium request allowance"
+- **Google subscription caps** — "You have exhausted your capacity on this model. Your quota will reset after …" (Gemini Code Assist), "You have reached the quota limit for …" / "You can resume using this model at …" (Antigravity)
+- **Hard allotments** — OpenRouter `free-models-per-day`, Alibaba "Allocated quota exceeded" (`Throttling.AllocationQuota`), GitHub Copilot "premium request allowance", z.ai GLM Coding Plan "Usage limit reached for 5 hour" / "no resource package"
 - **Budget exhaustion** — "out of budget", "Budget has been exceeded" (LiteLLM-style proxies), max/spending/monthly limits
 - **Suspended accounts** — "Your account … is suspended" (Kimi `exceeded_current_quota_error`)
 

package/package.json

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

@@ -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

@@ -142,10 +142,19 @@ const SILENCED_PATTERNS = [
 //                 "5-hour limit reached · resets 12pm"
 // - Codex:        "You've hit your usage limit. Upgrade to Plus"
 //                 "You've exceeded your usage limit."
+// + ChatGPT subscription plan caps (surfaced from chatgpt.com backend,
+//   observed via codex providers): "You have hit your ChatGPT usage limit
+//   (plus plan). Try again in ~5330 min." — plan name in parens varies
+//   (go/plus/pro/team); also arrives as HTTP 429 "The usage limit has been
+//   reached" with error.type `usage_limit_reached`
 // - OpenAI:       code "insufficient_quota" — "You exceeded your current
 //                 quota, please check your plan and billing details"
 // - Gemini:       same sentence in 429 RESOURCE_EXHAUSTED responses; only
 //                 reaches us after pi's built-in 429 retry gives up
+//   + Google AI Pro/Ultra subscription caps: "You have exhausted your
+//     capacity on this model. Your quota will reset after 8h44m7s." (Code
+//     Assist), "You have reached the quota limit for Claude Sonnet 4.5
+//     (Thinking). You can resume using this model at …" (Antigravity)
 // - OpenRouter:   "Rate limit exceeded: free-models-per-day. ..."
 // - Alibaba:      "Allocated quota exceeded, please increase your quota limit"
 //                 (Throttling.AllocationQuota — hard cap; RateQuota is
@@ -154,9 +163,21 @@ const SILENCED_PATTERNS = [
 // - LiteLLM:      "Budget has been exceeded! Current cost: …, Max budget: …"
 // - Kimi:         "Your account {org}<{ak}> is suspended, please check your
 //                 plan and billing details" (exceeded_current_quota_error)
+// - z.ai GLM:     "Usage limit reached for 5 hour. Your limit will reset at
+//                 …" (5-hour window, matches usage-limit-reached above) and
+//                 429 code 1113 "Insufficient balance or no resource package.
+//                 Please recharge." (Coding Plan quota drained — unlike plain
+//                 balance errors this needs a window reset or plan change)
+//
+// Deliberately retryable (verified, kept out): DeepSeek 402 "Insufficient
+// Balance" and 429 "Rate Limit Reached" (concurrency), Kimi TPD org limits
+// and "exceeded your current token quota" (balance). See the note on
+// hasQuotaExhaustedError below.
 export const QUOTA_EXHAUSTED_PATTERNS = [
-  // Session / usage limits with reset windows (Claude, Codex)
-  /hit your (usage )?limit/i,
+  // Session / usage limits with reset windows (Claude, Codex, ChatGPT plans)
+  /hit your (?:[a-z]+ )?usage limit/i, // "…hit your usage limit", "…hit your ChatGPT usage limit (plus plan)" — the optional word is the provider name; "hit your rate limit" intentionally NOT matched (burst limit stays retryable)
+  /hit your limit/i,
+  /usage_limit_reached/i, // Codex backend 429 error.type surfaced in the body
   /usage\s*limit\s*(has\s*been\s*)?reached/i,
   /hour\s*limit\s*reached/i, // "5-hour limit reached" — must NOT hit DeepSeek 429 "Rate Limit Reached"
   /limit\s*will\s*reset\s*at/i,
@@ -175,6 +196,13 @@ export const QUOTA_EXHAUSTED_PATTERNS = [
   /budget\s*(has\s*been\s*)?(exceeded|exhausted|limit)/i,
   /max(imum)?\s*budget\s*(exceeded|reached|limit)/i,
   /spending\s*limit/i,
+  // Google subscription caps (Gemini Code Assist, Antigravity)
+  /exhausted your capacity/i, // "You have exhausted your capacity on this model."
+  /quota will reset after/i, // "Your quota will reset after 8h44m7s."
+  /reached the quota limit/i, // Antigravity "You have reached the quota limit for Gemini 3 Pro (High)"
+  /you can resume using this model/i, // Antigravity resume tail when the lead-in is truncated
+  // z.ai / GLM Coding Plan window exhaustion (429 code 1113)
+  /no resource package/i, // "Insufficient balance or no resource package. Please recharge."
   // Suspended accounts (Kimi exceeded_current_quota_error suspended form)
   /account\b[^.]*\bis\s*suspended/i,
   // Generic
@@ -294,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';