oira666_pi-limits-wait 0.5.5 → 0.5.6

package/README.md

@@ -160,6 +160,7 @@ The extension rereads these files before every LLM call, so changes made during
 
 | Variable | Default | Description |
 |----------|---------|-------------|
+| `PI_LIMITS_WAIT_DISABLE_ALL_WAITING` | `false` | Master kill switch for this extension's error handling, retries, fallbacks, freezing, waiting, notifications, telemetry, and retry summaries. Set to `true` (also accepts `1`, `yes`, `on`) to leave only Anthropic OAuth system-prompt cleaning enabled; requests continue through Pi's normal runtime, including its normal Anthropic headers. This takes precedence over every setting below. |
 | `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 extension-created retries for an unclassified/unknown provider error. The initial failed request and provider-internal retries do not count. HTTP 400/403 remain eligible. Must be a non-negative integer. |
 | `PI_LIMITS_WAIT_LIVELINESS_INTERVAL` | `15` | Seconds between liveliness notifications published while waiting in non-interactive (`rpc`/`json`) modes. Must be a non-negative integer; values below 1 second are clamped to 1 second. Ignored in TUI mode. |

package/package.json

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

package/src/constants.ts

@@ -37,6 +37,7 @@ export const DEFAULT_LIVELINESS_INTERVAL_MS = 15 * 1_000; // 15 seconds
 
 export const SETTINGS_FILE_NAME = "limits-wait.json";
 export const FALLBACK_MODELS_KEY = "fallback-models";
+export const DISABLE_ALL_WAITING_ENV_VAR = "PI_LIMITS_WAIT_DISABLE_ALL_WAITING";
 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";

package/src/index.ts

@@ -3,9 +3,9 @@ import { isInternalSyntheticModel } from "./models.js";
 import { sanitiseAnthropicPayloadSystem } from "./prompt.js";
 import { RetrySummaryCoordinator } from "./retry-summary.js";
 import { loadFallbackSettings } from "./settings.js";
-import { loadUnknownErrorRetrySettings } from "./ui.js";
+import { allWaitingDisabled, loadUnknownErrorRetrySettings } from "./ui.js";
 import { consumeExpectedModelSelection, state } from "./state.js";
-import { installModelRuntimeInterception } from "./stream.js";
+import { disableModelRuntimeInterception, installModelRuntimeInterception } from "./stream.js";
 
 export { sanitiseAnthropicPayloadSystem, sanitiseSystemPrompt } from "./prompt.js";
 export {
@@ -46,11 +46,13 @@ export type { LimitsWaitSessionEntryData } from "./retry-summary.js";
 export {
   __configureFallbackModelsForTests,
   __setNonRetryableTuningForTests,
+  disableModelRuntimeInterception,
   installModelRuntimeInterception,
   streamWithLimitsRetry,
   streamWithRateLimitRetry,
 } from "./stream.js";
 export {
+  allWaitingDisabled,
   clearLivelinessStatus,
   freezingEnabled,
   isNonInteractiveHost,
@@ -63,16 +65,24 @@ export {
 export type { FallbackModel } from "./types.js";
 
 export default function (pi: ExtensionAPI) {
+  // Current pi-ai inserts the Claude Code identity as the first system block
+  // for Anthropic OAuth. Sanitise only that exact payload shape; authentication,
+  // identity insertion, Anthropic headers, and all other request composition
+  // remain owned by ModelRuntime.
+  pi.on("before_provider_request", (event) => sanitiseAnthropicPayloadSystem(event.payload));
+
+  // Keep prompt sanitisation and the runtime's normal Anthropic header path,
+  // but install no retry/error interception or retry-related lifecycle hooks.
+  if (allWaitingDisabled()) {
+    disableModelRuntimeInterception();
+    return;
+  }
+
   state.extensionApi = pi;
   loadUnknownErrorRetrySettings();
   const retrySummaries = new RetrySummaryCoordinator(pi);
   const releaseInterception = installModelRuntimeInterception(() => retrySummaries.createStream());
 
-  // Current pi-ai inserts the Claude Code identity as the first system block
-  // for Anthropic OAuth. Sanitise only that exact payload shape; authentication,
-  // identity insertion and all request composition remain owned by ModelRuntime.
-  pi.on("before_provider_request", (event) => sanitiseAnthropicPayloadSystem(event.payload));
-
   pi.on("model_select", (event) => {
     if (consumeExpectedModelSelection(event.model)) return;
     if (isInternalSyntheticModel(event.model)) return;

package/src/stream.ts

@@ -680,6 +680,23 @@ interface InterceptionSlot {
 }
 type InterceptablePrototype = ModelRuntime & { [INTERCEPTION_SYMBOL]?: InterceptionSlot };
 
+/**
+ * Deactivate the currently installed retry handler, if any. This is used by
+ * the all-waiting kill switch so reloading from an enabled extension instance
+ * cannot leave its process-wide interception active.
+ */
+export function disableModelRuntimeInterception(): void {
+  const prototype = ModelRuntime.prototype as InterceptablePrototype;
+  const slot = prototype[INTERCEPTION_SYMBOL];
+  if (!slot || prototype.streamSimple !== slot.wrapper) return;
+
+  const abortOwner = slot.abortOwner;
+  slot.owner = undefined;
+  slot.abortOwner = undefined;
+  slot.handler = undefined;
+  abortOwner?.();
+}
+
 /** Install one stable, reload-safe process-wide trampoline. */
 export function installModelRuntimeInterception(
   createRetryPeriod?: () => RetryPeriodTracker,

package/src/ui.ts

@@ -3,6 +3,7 @@ import {
   DEFAULT_UNKNOWN_ERROR_MAX_RETRIES,
   DEFAULT_UNKNOWN_ERROR_RETRY_INTERVAL_MS,
   DEFAULT_WAITING_ENV_VAR,
+  DISABLE_ALL_WAITING_ENV_VAR,
   FREEZING_ENV_VAR,
   LIVELINESS_INTERVAL_ENV_VAR,
   LIVELINESS_STATUS_KEY,
@@ -57,6 +58,10 @@ function envNonNegativeInteger(raw: string | undefined, defaultValue: number, ma
   return Number.isSafeInteger(value) ? Math.min(value, maximum) : defaultValue;
 }
 
+export function allWaitingDisabled(): boolean {
+  return envBoolean(process.env[DISABLE_ALL_WAITING_ENV_VAR], false);
+}
+
 export function freezingEnabled(): boolean {
   return envBoolean(process.env[FREEZING_ENV_VAR], true);
 }