oira666_pi-limits-wait 0.4.9 → 0.4.11

package/README.md

@@ -21,8 +21,8 @@ Restart Pi or run `/reload` after installing.
 - On `server_is_overloaded`, waits 5 minutes, then retries. If the provider is still overloaded after Pi's normal retries, it waits another 5 minutes and repeats.
 - On transient network/transport failures — including undici idle-timeout aborts (`UND_ERR_HEADERS_TIMEOUT` / `UND_ERR_BODY_TIMEOUT`), `fetch failed`, `terminated`, `ECONNRESET`, `ETIMEDOUT`, etc. — treats the error as retryable with a short backoff (default 15s, or the provider's `retry-after`) instead of giving up. This prevents a stalled streaming request from turning into a silent hang.
 - For any other (unclassified) non-retryable error, retries the same model a few times (default 3) before falling back / freezing it, so a one-off hiccup does not immediately sideline a model.
-- Shows a countdown in the Pi status/working line.
-- Press Enter during the countdown to skip the wait and retry immediately.
+- Reports retry/fallback waits in chat notifications without adding persistent TUI status lines.
+- Press Enter during a retry wait to skip the wait and retry immediately.
 - Optionally falls back to configured models when the current/default model is rate-limited.
 
 ## Optional fallback models
@@ -74,7 +74,7 @@ Fallback behavior:
 4. If that model later becomes rate-limited too, the extension starts again from the same ordered list.
 5. Rate-limit reset times are remembered only in memory, so known-limited models are skipped until their countdown expires. This memory is cleared when Pi restarts.
 
-When the settings are loaded, the extension shows the full usable fallback model list. When models become rate-limited, it shows a live countdown for each limited model.
+When the settings are loaded, the extension shows the full usable fallback model list. When models become rate-limited, it reports the wait in chat notifications.
 
 ## Environment variables
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-limits-wait",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "Extension for PI that allows to automatically wait for limits to reset and retry the request",
   "type": "module",
   "license": "MIT",

package/src/constants.ts

@@ -0,0 +1,23 @@
+export const CLAUDE_CODE_IDENTITY =
+  "You are Claude Code, Anthropic's official CLI for Claude.";
+
+export const PI_REMOVAL_ANCHORS = [
+  "pi-coding-agent",
+  "@mariozechner/pi-coding-agent",
+  "badlogic/pi-mono",
+] as const;
+
+export const PI_IDENTITY_SENTENCE_PATTERN =
+  /(?:^|\n)\s*You are pi\b[^.!?\n]*(?:[.!?](?=\s|$)|(?=\n|$))/gi;
+
+export const DEFAULT_RATE_LIMIT_WAIT_MS = 30 * 60 * 1_000; // 30 minutes
+export const DEFAULT_OVERLOADED_WAIT_MS = 5 * 60 * 1_000; // 5 minutes
+export const DEFAULT_NETWORK_WAIT_MS = 15 * 1_000; // 15 seconds
+export const DEFAULT_NON_RETRYABLE_FREEZE_MS = 10 * 60 * 1_000; // 10 minutes
+
+export const NON_RETRYABLE_MAX_ATTEMPTS = 3;
+export const NON_RETRYABLE_RETRY_DELAY_MS = 5 * 1_000; // 5 seconds
+
+export const SETTINGS_FILE_NAME = "limits-wait.json";
+export const FALLBACK_MODELS_KEY = "fallback-models";
+export const FREEZING_ENV_VAR = "PI_LIMITS_WAIT_FREEZING_ENABLED";

package/src/fetch-observer.ts

@@ -0,0 +1,49 @@
+import { DEFAULT_RATE_LIMIT_WAIT_MS } from "./constants.js";
+import { retryAfterHeaderMs } from "./retry-errors.js";
+import { state } from "./state.js";
+import { formatErrorDetail, showAmbientRetryStatus, clearAmbientRetryStatus } from "./ui.js";
+
+async function responseErrorMessage(response: Response): Promise<string> {
+  const retryAfterMs = retryAfterHeaderMs(response.headers);
+  const retryAfter = retryAfterMs !== undefined ? ` retry-after-ms ${retryAfterMs}` : "";
+  let body = "";
+  try {
+    body = await response.clone().text();
+  } catch {
+    // Ignore body read failures; status and retry headers are enough.
+  }
+  const detail = body.trim() ? ` ${formatErrorDetail(body)}` : "";
+  return `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}${retryAfter}${detail}`;
+}
+
+export function installFetchRateLimitObserver(): void {
+  if (state.restoreFetch || typeof globalThis.fetch !== "function") return;
+
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  globalThis.fetch = (async (...args: Parameters<typeof fetch>) => {
+    const response = await originalFetch(...args);
+
+    if (state.activeProviderRequests > 0) {
+      if (!response.ok) {
+        const message = await responseErrorMessage(response);
+        state.lastObservedHttpError = { at: Date.now(), message };
+        if (response.status === 429) {
+          const waitMs = retryAfterHeaderMs(response.headers) ?? DEFAULT_RATE_LIMIT_WAIT_MS;
+          showAmbientRetryStatus("rate-limit", waitMs);
+          if (state.activeFallbackProviderRequests > 0) {
+            throw new Error(message);
+          }
+        }
+      } else if (state.ambientStatusCleanup && response.ok) {
+        clearAmbientRetryStatus();
+      }
+    }
+
+    return response;
+  }) as typeof fetch;
+
+  state.restoreFetch = () => {
+    globalThis.fetch = originalFetch as typeof fetch;
+    state.restoreFetch = undefined;
+  };
+}