oira666_pi-limits-wait 0.5.3 → 0.5.4

package/README.md

@@ -22,6 +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.
+- Leaves context-overflow recovery entirely to Pi. The extension uses Pi's own `isContextOverflow()` detector and immediately surfaces matching failures without waiting, retrying, or selecting another fallback. If the overflow came from a fallback already attempted for the request, the extension makes that attempted model current when Pi is still on the request's original model and accepts the switch; it never overrides a newer user model selection. Pi intentionally ignores overflow errors from non-current models. Successful over-window responses and zero-output length stops also pass through unchanged, allowing Pi to compact and perform its built-in recovery.
 - For any other (unclassified) provider error — including an API `Internal server error` and HTTP `400`/`403` failures — waits and retries the same model. There is deliberately no permanent-HTTP-status allowlist. This retry-all behavior 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.

package/package.json

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

package/src/models.ts

@@ -121,13 +121,22 @@ export function initialAttempt(model: Model<Api>): FallbackModel {
 
 let modelSwitchQueue = Promise.resolve();
 
-export async function switchPiModel(entry: FallbackModel, signal?: AbortSignal): Promise<void> {
+export async function switchPiModel(
+  entry: FallbackModel,
+  signal?: AbortSignal,
+  canSelect?: (current: Model<Api> | undefined) => boolean,
+): Promise<boolean> {
+  let selected = false;
   const operation = modelSwitchQueue.then(async () => {
     if (signal?.aborted) return;
     const pi = state.extensionApi;
     if (!pi) return;
     const current = state.sharedCtx?.model;
-    if (current && modelKey(current) === modelKey(entry.model)) return;
+    if (current && modelKey(current) === modelKey(entry.model)) {
+      selected = true;
+      return;
+    }
+    if (canSelect && !canSelect(current)) return;
     if (signal?.aborted) return;
 
     const cancelExpectedSelection = expectModelSelection(entry.model);
@@ -138,6 +147,7 @@ export async function switchPiModel(entry: FallbackModel, signal?: AbortSignal):
         return;
       }
       if (signal?.aborted) return;
+      selected = true;
       const level = entry.reasoningEffort ?? state.primaryThinkingLevel;
       if (level) pi.setThinkingLevel(level);
       if (!signal?.aborted) {
@@ -152,4 +162,5 @@ export async function switchPiModel(entry: FallbackModel, signal?: AbortSignal):
   });
   modelSwitchQueue = operation.catch(() => undefined);
   await operation;
+  return selected;
 }

package/src/stream.ts

@@ -1,6 +1,7 @@
 import { ModelRuntime, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   createAssistantMessageEventStream,
+  isContextOverflow,
   type Api,
   type AssistantMessage,
   type AssistantMessageEvent,
@@ -66,12 +67,10 @@ function freshMessage(model: Model<Api>): AssistantMessage {
   };
 }
 
-function isAbortErrorEvent(event: AssistantMessageEvent, signal?: AbortSignal): boolean {
+function isExplicitAbortErrorEvent(event: AssistantMessageEvent, signal?: AbortSignal): boolean {
   if (signal?.aborted) return true;
   if (event.type !== "error") return false;
-  return event.reason === "aborted"
-    || event.error.stopReason === "aborted"
-    || isAbortMessage(event.error.errorMessage ?? "");
+  return event.reason === "aborted" || event.error.stopReason === "aborted";
 }
 
 function responseErrorMessage(response: ProviderResponse): string {
@@ -191,6 +190,21 @@ export function streamWithLimitsRetry(
     const nonRetryableAttempts = new Map<string, number>();
     const triedModels = new Set<string>();
 
+    const prepareAttemptForPi = async (): Promise<boolean> => {
+      const originalKey = modelKey(model);
+      const attemptKey = modelKey(attempt.model);
+      if (attemptKey === originalKey) return true;
+      const canSelect = (current: Model<Api> | undefined) => {
+        if (!current) return true;
+        const currentKey = modelKey(current);
+        // Never undo a newer, unrelated user model selection. Pi deliberately
+        // treats the resulting overflow as stale instead of compacting for it.
+        return currentKey === originalKey || currentKey === attemptKey;
+      };
+      if (!canSelect(state.sharedCtx?.model)) return false;
+      return switchPiModel(attempt, signal, canSelect);
+    };
+
     const managedWait = async (reason: RetryReason, waitMs: number, error: string) =>
       waitForRetry(reason, waitMs, signal, {
         periodId: retryPeriod?.periodId,
@@ -329,14 +343,45 @@ export function streamWithLimitsRetry(
             if (!committed) {
               if (event.type === "error") {
                 const errMsg = enrichError(event.error.errorMessage ?? "", observedHttpError);
-                if (isAbortErrorEvent(event, signal)) {
+                if (isExplicitAbortErrorEvent(event, signal)) {
+                  if (buffer.length > 0) flush(buffer);
+                  pushAbort(errMsg || "Operation aborted");
+                  return;
+                }
+                const surfacedEvent = errMsg === (event.error.errorMessage ?? "")
+                  ? event
+                  : { ...event, error: { ...event.error, errorMessage: errMsg } };
+                // Pi owns context-overflow recovery. Use Pi's canonical detector
+                // before this extension's message heuristics so mixed transport/
+                // abort wording cannot hide a real overflow from the host.
+                if (isContextOverflow(surfacedEvent.error, attempt.model.contextWindow)) {
+                  // If this request had already moved to a fallback attempt,
+                  // commit that attempted model when safe. Pi intentionally
+                  // ignores overflow errors from a non-current model.
+                  await prepareAttemptForPi();
+                  if (signal?.aborted) {
+                    pushAbort("Request aborted while switching model for context-overflow recovery.");
+                    return;
+                  }
+                  retryPeriod?.finalize();
+                  if (buffer.length > 0) flush(buffer);
+                  else {
+                    output.push({ type: "start", partial: freshMessage(attempt.model) });
+                    committed = true;
+                  }
+                  output.push(surfacedEvent);
+                  finished = true;
+                  output.end();
+                  return;
+                }
+                if (isAbortMessage(errMsg)) {
                   if (buffer.length > 0) flush(buffer);
                   pushAbort(errMsg || "Operation aborted");
                   return;
                 }
                 retryable = getRetryableError(errMsg);
                 if (retryable) retryableErrorMessage = errMsg;
-                else nonRetryableError = { message: errMsg, event };
+                else nonRetryableError = { message: errMsg, event: surfacedEvent };
                 break;
               }
 
@@ -350,7 +395,7 @@ export function streamWithLimitsRetry(
                   pushAbort("Request aborted before switching model.");
                   return;
                 }
-                await switchPiModel(attempt, signal);
+                await prepareAttemptForPi();
                 if (signal?.aborted) {
                   pushAbort("Request aborted while switching model.");
                   return;
@@ -381,17 +426,61 @@ export function streamWithLimitsRetry(
             }
           }
         });
-        await deliverObservedResponses();
-        if (finished) return;
-      } catch (caught) {
-        let err = caught;
         try {
           await deliverObservedResponses();
         } catch (responseError) {
-          err = responseError;
+          // A terminal provider event has already been surfaced. Observer
+          // callback failures must not start a hidden retry behind that event.
+          if (finished) return;
+          throw responseError;
+        }
+        if (finished) return;
+      } catch (caught) {
+        let err = caught;
+        const caughtMessage = errorMessageWithCauses(caught);
+        const caughtAssistant = freshMessage(attempt.model);
+        caughtAssistant.stopReason = "error";
+        caughtAssistant.errorMessage = caughtMessage;
+        const caughtIsOverflow = isContextOverflow(caughtAssistant, attempt.model.contextWindow);
+        if (caughtIsOverflow) {
+          // Response callbacks are observational here. Never let a slow or
+          // failing callback delay a provider overflow from reaching Pi.
+          void deliverObservedResponses().catch(() => undefined);
+        } else {
+          try {
+            await deliverObservedResponses();
+          } catch (responseError) {
+            err = responseError;
+          }
         }
         const errMsg = enrichError(errorMessageWithCauses(err), observedHttpError ?? errorHttpMetadata(err));
-        const aborted = Boolean(signal?.aborted) || isAbortMessage(errMsg);
+        const explicitlyAborted = Boolean(signal?.aborted);
+        const error = freshMessage(attempt.model);
+        error.stopReason = "error";
+        error.errorMessage = errMsg;
+        // Synchronous provider throws do not include an AssistantMessage event,
+        // so build the same terminal shape Pi receives and apply Pi's detector
+        // before classifying network or message-based abort heuristics.
+        if (!explicitlyAborted && isContextOverflow(error, attempt.model.contextWindow)) {
+          await prepareAttemptForPi();
+          if (signal?.aborted) {
+            pushAbort("Request aborted while switching model for context-overflow recovery.");
+            return;
+          }
+          retryPeriod?.finalize();
+          if (!committed) {
+            if (buffer.length > 0) flush(buffer);
+            else {
+              output.push({ type: "start", partial: freshMessage(attempt.model) });
+              committed = true;
+            }
+          }
+          output.push({ type: "error", reason: "error", error });
+          finished = true;
+          output.end();
+          return;
+        }
+        const aborted = explicitlyAborted || isAbortMessage(errMsg);
         retryable = aborted ? undefined : getRetryableError(errMsg);
         if (retryable) retryableErrorMessage = errMsg;
         else if (aborted) {