oira666_pi-limits-wait 0.5.0 → 0.5.2

package/README.md

@@ -22,7 +22,7 @@ Restart Pi or run `/reload` after installing.
 - If no retry timing is available for a rate limit, waits 30 minutes before retrying.
 - 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.
+- For any other (unclassified) provider error — including an API `Internal server error` — waits and retries the same model. This is enabled by default and uses a configurable retry limit and interval; it does not alter model-limit wait intervals.
 - 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. Every fallback to a different model—even on the same provider—deliberately discards request-owned credentials, headers, environment overrides, and provider-specific options so the target runtime resolves its own configuration.
@@ -81,13 +81,16 @@ 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 reports the wait in chat notifications.
+The extension rereads these files before every LLM call, so changes made during a long-running task take effect on the next LLM call without restarting Pi or using `/reload`. Tool calls do not trigger a settings read. 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
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `PI_LIMITS_WAIT_FREEZING_ENABLED` | `true` | When a model keeps failing with a non-retryable error, it is normally "frozen" for 1 hour and skipped in favour of other configured models. Set this to `false` (also accepts `0`, `no`, `off`) to disable freezing entirely: the extension will instead try each configured candidate once (after the bounded retries) and then surface the error, never blocking on a long "model-frozen" wait. Useful for non-interactive / subagent runs where no one can press Enter to skip. |
+| `PI_LIMITS_WAIT_DEFAULT_WAITING` | `true` | Whether unclassified/unknown provider errors enter the wait-and-retry cycle. Set to `false` (also accepts `0`, `no`, `off`) to surface the error immediately. Rate-limit, overload, authentication, and network retry behavior is unchanged. |
+| `PI_LIMITS_WAIT_MAX_RETRY` | `999999` | Maximum retries for an unclassified/unknown provider error. The initial failed request does not count as a retry. Must be a non-negative integer. |
+| `PI_LIMITS_WAIT_RETRY_INTERVAL` | `5` | Seconds to wait between unclassified/unknown provider-error retries. Must be a non-negative integer (values above 2147483 are capped to Node's maximum reliable timer delay). This does not affect model-limit wait intervals. |
+| `PI_LIMITS_WAIT_FREEZING_ENABLED` | `true` | When a model keeps failing with a non-retryable error, it is normally "frozen" for 10 minutes and skipped in favour of other configured models. Set this to `false` (also accepts `0`, `no`, `off`) to disable freezing entirely: the extension will instead try each configured candidate once (after the bounded retries) and then surface the error, never blocking on a long "model-frozen" wait. Useful for non-interactive / subagent runs where no one can press Enter to skip. |
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-limits-wait",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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

@@ -25,9 +25,14 @@ 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
+// Unknown provider errors are retried separately from rate-limit, overload,
+// authentication, and network failures.
+export const DEFAULT_UNKNOWN_ERROR_MAX_RETRIES = 999_999;
+export const DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_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";
+export const DEFAULT_WAITING_ENV_VAR = "PI_LIMITS_WAIT_DEFAULT_WAITING";
+export const MAX_RETRY_ENV_VAR = "PI_LIMITS_WAIT_MAX_RETRY";
+export const RETRY_INTERVAL_ENV_VAR = "PI_LIMITS_WAIT_RETRY_INTERVAL";

package/src/index.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isInternalSyntheticModel } from "./models.js";
 import { sanitiseAnthropicPayloadSystem } from "./prompt.js";
 import { loadFallbackSettings } from "./settings.js";
+import { loadUnknownErrorRetrySettings } from "./ui.js";
 import { consumeExpectedModelSelection, state } from "./state.js";
 import { installModelRuntimeInterception } from "./stream.js";
 
@@ -28,11 +29,12 @@ export {
   streamWithLimitsRetry,
   streamWithRateLimitRetry,
 } from "./stream.js";
-export { freezingEnabled, waitForRateLimit, waitForRetry } from "./ui.js";
+export { freezingEnabled, loadUnknownErrorRetrySettings, waitForRateLimit, waitForRetry } from "./ui.js";
 export type { FallbackModel } from "./types.js";
 
 export default function (pi: ExtensionAPI) {
   state.extensionApi = pi;
+  loadUnknownErrorRetrySettings();
   const releaseInterception = installModelRuntimeInterception();
 
   // Current pi-ai inserts the Claude Code identity as the first system block

package/src/state.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
-import { NON_RETRYABLE_MAX_ATTEMPTS, NON_RETRYABLE_RETRY_DELAY_MS } from "./constants.js";
+import { DEFAULT_UNKNOWN_ERROR_MAX_RETRIES, DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS } from "./constants.js";
 import type { FallbackModel, NonRetryableFailureMemory, RateLimitMemory } from "./types.js";
 
 export const state = {
@@ -9,8 +9,10 @@ export const state = {
   ambientStatusCleanup: undefined as (() => void) | undefined,
   modelStatusCleanup: undefined as (() => void) | undefined,
   fallbackModels: [] as FallbackModel[],
-  nonRetryableMaxAttempts: NON_RETRYABLE_MAX_ATTEMPTS,
-  nonRetryableRetryDelayMs: NON_RETRYABLE_RETRY_DELAY_MS,
+  unknownErrorWaitingEnabled: true,
+  // Includes the initial request, so the default is one more than max retries.
+  nonRetryableMaxAttempts: DEFAULT_UNKNOWN_ERROR_MAX_RETRIES + 1,
+  nonRetryableRetryDelayMs: DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS,
   primaryModel: undefined as Model<Api> | undefined,
   primaryThinkingLevel: undefined as ModelThinkingLevel | undefined,
   expectedModelSelections: new Map<string, Set<symbol>>(),

package/src/stream.ts

@@ -28,6 +28,7 @@ import {
 } from "./models.js";
 import { withAttemptResponseObserver } from "./response-observer.js";
 import { errorMessageWithCauses, getRetryableError, isAbortMessage, parseRetryDelayMs, retryAfterHeaderMs } from "./retry-errors.js";
+import { loadFallbackSettings } from "./settings.js";
 import { state } from "./state.js";
 import type { FallbackModel, RetryableError, RuntimeStreamSimpleFn } from "./types.js";
 import { clearModelStatus, freezingEnabled, reasonLabel, waitForRetry } from "./ui.js";
@@ -173,6 +174,11 @@ export function streamWithLimitsRetry(
     ? AbortSignal.any([options.signal, ownerSignal])
     : options?.signal ?? ownerSignal;
 
+  // A long-running agent task can make many LLM calls between tool calls.
+  // Refresh here—not only in before_agent_start—so project settings edited
+  // during that task take effect on the next LLM call without /reload.
+  if (state.sharedCtx?.modelRegistry) loadFallbackSettings(state.sharedCtx);
+
   void (async () => {
     let committed = false;
     let finished = false;
@@ -405,7 +411,7 @@ export function streamWithLimitsRetry(
           output.end();
         };
 
-        if (!committed) {
+        if (!committed && state.unknownErrorWaitingEnabled) {
           const key = modelKey(attempt.model);
           const attempts = (nonRetryableAttempts.get(key) ?? 0) + 1;
           nonRetryableAttempts.set(key, attempts);

package/src/ui.ts

@@ -1,4 +1,11 @@
-import { FREEZING_ENV_VAR } from "./constants.js";
+import {
+  DEFAULT_UNKNOWN_ERROR_MAX_RETRIES,
+  DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS,
+  DEFAULT_WAITING_ENV_VAR,
+  FREEZING_ENV_VAR,
+  MAX_RETRY_ENV_VAR,
+  RETRY_INTERVAL_ENV_VAR,
+} from "./constants.js";
 import { state } from "./state.js";
 import type { RetryReason } from "./types.js";
 
@@ -25,13 +32,43 @@ export function reasonLabel(reason: RetryReason): string {
   return "Rate limited";
 }
 
-export function freezingEnabled(): boolean {
-  const raw = process.env[FREEZING_ENV_VAR];
-  if (raw === undefined) return true;
+function envBoolean(raw: string | undefined, defaultValue: boolean): boolean {
+  if (raw === undefined) return defaultValue;
   const value = raw.trim().toLowerCase();
   return !(value === "false" || value === "0" || value === "no" || value === "off");
 }
 
+function envNonNegativeInteger(raw: string | undefined, defaultValue: number, maximum = Number.MAX_SAFE_INTEGER): number {
+  if (raw === undefined || !/^\d+$/.test(raw.trim())) return defaultValue;
+  const value = Number(raw);
+  return Number.isSafeInteger(value) ? Math.min(value, maximum) : defaultValue;
+}
+
+export function freezingEnabled(): boolean {
+  return envBoolean(process.env[FREEZING_ENV_VAR], true);
+}
+
+/** Load unknown-error retry settings once per extension instance/reload. */
+export function loadUnknownErrorRetrySettings(): void {
+  state.unknownErrorWaitingEnabled = envBoolean(process.env[DEFAULT_WAITING_ENV_VAR], true);
+  const maxRetries = envNonNegativeInteger(
+    process.env[MAX_RETRY_ENV_VAR],
+    DEFAULT_UNKNOWN_ERROR_MAX_RETRIES,
+    Number.MAX_SAFE_INTEGER - 1,
+  );
+  // The first failed request is not itself a retry.
+  state.nonRetryableMaxAttempts = maxRetries + 1;
+
+  // PI_LIMITS_WAIT_RETRY_INTERVAL is expressed in seconds; internally waits use ms.
+  const intervalSeconds = envNonNegativeInteger(
+    process.env[RETRY_INTERVAL_ENV_VAR],
+    DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS / 1_000,
+    // Node timers cannot reliably wait longer than this in one timeout.
+    Math.floor(2_147_483_647 / 1_000),
+  );
+  state.nonRetryableRetryDelayMs = intervalSeconds * 1_000;
+}
+
 function countdownText(reason: RetryReason, deadline: number, allowSkip: boolean): string {
   const remaining = Math.max(0, deadline - Date.now());
   const totalSecs = Math.ceil(remaining / 1_000);