oira666_pi-limits-wait 0.4.5 → 0.4.8

package/README.md

@@ -27,38 +27,36 @@ Restart Pi or run `/reload` after installing.
 
 By default, if you do not configure fallback models, the extension behaves exactly as before: it waits for the current model's limit to reset and retries.
 
-To enable automatic model fallback, add `oira666_pi-limits-wait.try_models` to Pi's normal `settings.json`.
+To enable automatic model fallback, add `fallback-models` to a `limits-wait.json` file.
 
-Pi settings can be global or project-local:
+The extension reads these files in order; later files override earlier ones:
 
 | Location | Scope |
 |----------|-------|
-| `~/.pi/agent/settings.json` | Global, all projects |
-| `.pi/settings.json` | Project-local |
-
-Project settings override global settings. The extension reads these through Pi's `SettingsManager`, so normal Pi settings paths and `PI_CODING_AGENT_DIR` are respected.
+| `~/.config/.pi/limits-wait.json` | Global defaults |
+| `<Pi agent dir>/limits-wait.json` (for example `~/.pi/agent/limits-wait.json`, or `PI_CODING_AGENT_DIR/limits-wait.json`) | Pi agent directory |
+| `.limits-wait.json` | Project root override |
+| `.pi/limits-wait.json` | Pi project override |
 
 Example:
 
 ```json
 {
-  "oira666_pi-limits-wait": {
-    "try_models": [
-      {
-        "provider": "anthropic",
-        "modelname": "claude-sonnet-4-5",
-        "reasoning effort": "medium"
-      },
-      {
-        "provider": "openai",
-        "modelname": "gpt-5.1-codex"
-      }
-    ]
-  }
+  "fallback-models": [
+    {
+      "provider": "anthropic",
+      "modelname": "claude-sonnet-4-5",
+      "reasoning effort": "medium"
+    },
+    {
+      "provider": "openai",
+      "modelname": "gpt-5.1-codex"
+    }
+  ]
 }
 ```
 
-Each `try_models` entry supports:
+Each `fallback-models` entry supports:
 
 - `provider` — required. The Pi provider name, for example `anthropic`, `openai`, `google`, etc.
 - `modelname` — required. The model id/name as Pi knows it.
@@ -69,7 +67,7 @@ Fallback behavior:
 1. Pi starts with the normal default or user-selected model.
 2. If that model is rate-limited, the extension tries models in this order:
    - the original default/user-selected model;
-   - then every model from `oira666_pi-limits-wait.try_models`, top to bottom.
+   - then every model from `fallback-models`, top to bottom.
 3. The first model that responds without a rate-limit becomes the active Pi model for the rest of the session/task.
 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.

package/package.json

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

package/src/index.ts

@@ -1,4 +1,7 @@
-import { SettingsManager, type ExtensionAPI, type ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
 import {
   createAssistantMessageEventStream,
@@ -29,7 +32,8 @@ const PI_IDENTITY_SENTENCE_PATTERN =
 const DEFAULT_RATE_LIMIT_WAIT_MS = 30 * 60 * 1_000; // 30 minutes
 const DEFAULT_OVERLOADED_WAIT_MS = 5 * 60 * 1_000; // 5 minutes
 const DEFAULT_NON_RETRYABLE_FREEZE_MS = 60 * 60 * 1_000; // 1 hour
-const SETTINGS_KEY = "oira666_pi-limits-wait";
+const SETTINGS_FILE_NAME = "limits-wait.json";
+const FALLBACK_MODELS_KEY = "fallback-models";
 
 /** Key used with ctx.ui.setStatus() for the countdown line. */
 const STATUS_KEY = "limits-wait";
@@ -59,6 +63,12 @@ type RateLimitMemory = {
   deadline: number;
 };
 
+type NonRetryableFailureMemory = {
+  failedAt: number;
+  deadline: number;
+  errorMessage: string;
+};
+
 // ─── Shared UI context ────────────────────────────────────────────────────────
 
 let sharedCtx: ExtensionContext | undefined;
@@ -67,6 +77,8 @@ let restoreFetch: (() => void) | undefined;
 let ambientStatusCleanup: (() => void) | undefined;
 let modelStatusCleanup: (() => void) | undefined;
 let activeProviderRequests = 0;
+let activeFallbackProviderRequests = 0;
+let lastObservedRateLimitError: { at: number; message: string } | undefined;
 const wrappedApis = new Set<Api>();
 const builtinStreamSimpleByApi = new Map<Api, StreamSimpleFn>();
 let fallbackModels: FallbackModel[] = [];
@@ -75,7 +87,7 @@ let primaryThinkingLevel: ThinkingLevel | undefined;
 let suppressNextModelSelect = false;
 let settingsSignature: string | undefined;
 const rateLimitMemory = new Map<string, RateLimitMemory>();
-const nonRetryableFailureMemory = new Map<string, { failedAt: number; deadline: number; errorMessage: string }>();
+const nonRetryableFailureMemory = new Map<string, NonRetryableFailureMemory>();
 
 // ─── Anthropic subscription prompt sanitisation ──────────────────────────────
 
@@ -130,8 +142,8 @@ function isThinkingLevel(value: unknown): value is ThinkingLevel {
 }
 
 function parseConfiguredModels(raw: unknown): ConfiguredModel[] {
-  const source = raw && typeof raw === "object" && Array.isArray((raw as { try_models?: unknown }).try_models)
-    ? (raw as { try_models: unknown[] }).try_models
+  const source = raw && typeof raw === "object" && Array.isArray((raw as { [FALLBACK_MODELS_KEY]?: unknown })[FALLBACK_MODELS_KEY])
+    ? (raw as { [FALLBACK_MODELS_KEY]: unknown[] })[FALLBACK_MODELS_KEY]
     : [];
 
   const models: ConfiguredModel[] = [];
@@ -155,37 +167,77 @@ function parseConfiguredModels(raw: unknown): ConfiguredModel[] {
   return models;
 }
 
+function configFileCandidates(cwd: string, agentDir = getAgentDir(), homeDir = homedir()): string[] {
+  return [
+    join(homeDir, ".config", ".pi", SETTINGS_FILE_NAME),
+    join(agentDir, SETTINGS_FILE_NAME),
+    resolve(cwd, `.${SETTINGS_FILE_NAME}`),
+    resolve(cwd, ".pi", SETTINGS_FILE_NAME),
+  ];
+}
+
+function mergeConfig(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> {
+  return { ...base, ...override };
+}
+
+function readFallbackSettings(cwd: string, agentDir = getAgentDir(), homeDir = homedir()): { config: Record<string, unknown>; loadedPaths: string[]; warnings: string[] } {
+  let config: Record<string, unknown> = {};
+  const loadedPaths: string[] = [];
+  const warnings: string[] = [];
+  const seen = new Set<string>();
+
+  for (const candidate of configFileCandidates(cwd, agentDir, homeDir)) {
+    const path = resolve(candidate);
+    if (seen.has(path)) continue;
+    seen.add(path);
+    if (!existsSync(path)) continue;
+
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        warnings.push(`${path}: expected a JSON object`);
+        continue;
+      }
+      config = mergeConfig(config, parsed as Record<string, unknown>);
+      loadedPaths.push(path);
+    } catch (err) {
+      warnings.push(`${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  return { config, loadedPaths, warnings };
+}
+
+export function __readFallbackSettingsForTests(cwd: string, agentDir: string, homeDir: string): { config: Record<string, unknown>; loadedPaths: string[]; warnings: string[] } {
+  return readFallbackSettings(cwd, agentDir, homeDir);
+}
+
 function loadFallbackSettings(ctx: ExtensionContext): void {
   fallbackModels = [];
 
   try {
-    const settingsManager = SettingsManager.create(ctx.cwd);
-    const globalSettings = settingsManager.getGlobalSettings() as Record<string, unknown>;
-    const projectSettings = settingsManager.getProjectSettings() as Record<string, unknown>;
-    const globalConfig = globalSettings[SETTINGS_KEY];
-    const projectConfig = projectSettings[SETTINGS_KEY];
-    const config = {
-      ...(globalConfig && typeof globalConfig === "object" && !Array.isArray(globalConfig) ? globalConfig : {}),
-      ...(projectConfig && typeof projectConfig === "object" && !Array.isArray(projectConfig) ? projectConfig : {}),
-    };
-    const content = JSON.stringify(config);
+    const { config, loadedPaths, warnings } = readFallbackSettings(ctx.cwd);
+    const content = JSON.stringify({ config, loadedPaths, warnings });
     const shouldNotify = settingsSignature !== content;
     settingsSignature = content;
 
     const configured = parseConfiguredModels(config);
-    if (configured.length === 0) return;
+    if (configured.length === 0) {
+      if (shouldNotify && warnings.length > 0) ctx.ui.notify(`Could not fully load ${SETTINGS_FILE_NAME}: ${warnings.join(", ")}`, "warning");
+      return;
+    }
 
-    const warnings: string[] = [];
+    const modelWarnings: string[] = [];
     const seen = new Set<string>();
 
     for (const entry of configured) {
       const model = ctx.modelRegistry.find(entry.provider, entry.modelname);
       if (!model) {
-        warnings.push(`missing ${entry.provider}/${entry.modelname}`);
+        modelWarnings.push(`missing ${entry.provider}/${entry.modelname}`);
         continue;
       }
       if (!ctx.modelRegistry.hasConfiguredAuth(model)) {
-        warnings.push(`no auth ${entry.provider}/${entry.modelname}`);
+        modelWarnings.push(`no auth ${entry.provider}/${entry.modelname}`);
         continue;
       }
       const key = modelKey(model);
@@ -197,14 +249,16 @@ function loadFallbackSettings(ctx: ExtensionContext): void {
     const lines = fallbackModels.map((entry, index) =>
       `${index + 1}. ${formatModel(entry.model)}${entry.reasoningEffort ? ` (${entry.reasoningEffort})` : ""}`,
     );
+    const source = loadedPaths.length > 0 ? ` from ${loadedPaths.join(", ")}` : "";
     const message = lines.length > 0
-      ? `Loaded ${SETTINGS_KEY}.try_models:\n${lines.join("\n")}`
-      : `Loaded ${SETTINGS_KEY}.try_models, but no usable fallback models were found.`;
+      ? `Loaded ${SETTINGS_FILE_NAME}.${FALLBACK_MODELS_KEY}${source}:\n${lines.join("\n")}`
+      : `Loaded ${SETTINGS_FILE_NAME}.${FALLBACK_MODELS_KEY}${source}, but no usable fallback models were found.`;
+    const allWarnings = [...warnings, ...modelWarnings];
     if (shouldNotify) {
-      ctx.ui.notify(warnings.length > 0 ? `${message}\nSkipped: ${warnings.join(", ")}` : message, warnings.length > 0 ? "warning" : "info");
+      ctx.ui.notify(allWarnings.length > 0 ? `${message}\nSkipped: ${allWarnings.join(", ")}` : message, allWarnings.length > 0 ? "warning" : "info");
     }
   } catch (err) {
-    ctx.ui.notify(`Could not load ${SETTINGS_KEY}.try_models: ${err instanceof Error ? err.message : String(err)}`, "warning");
+    ctx.ui.notify(`Could not load ${SETTINGS_FILE_NAME}.${FALLBACK_MODELS_KEY}: ${err instanceof Error ? err.message : String(err)}`, "warning");
   }
 }
 
@@ -250,27 +304,31 @@ function formatDuration(ms: number): string {
 function updateRateLimitedModelsStatus(): void {
   const ctx = sharedCtx;
   if (!ctx) return;
-  const now = Date.now();
-  const lines: string[] = [];
-  for (const [key, entry] of rateLimitMemory) {
-    if (now >= entry.deadline) {
-      rateLimitMemory.delete(key);
-      continue;
+  try {
+    const now = Date.now();
+    const lines: string[] = [];
+    for (const [key, entry] of rateLimitMemory) {
+      if (now >= entry.deadline) {
+        rateLimitMemory.delete(key);
+        continue;
+      }
+      lines.push(`${key}: ${formatDuration(entry.deadline - now)}`);
     }
-    lines.push(`${key}: ${formatDuration(entry.deadline - now)}`);
-  }
-  for (const [key, entry] of nonRetryableFailureMemory) {
-    if (now >= entry.deadline) {
-      nonRetryableFailureMemory.delete(key);
-      continue;
+    for (const [key, entry] of nonRetryableFailureMemory) {
+      if (now >= entry.deadline) {
+        nonRetryableFailureMemory.delete(key);
+        continue;
+      }
+      lines.push(`${key}: frozen ${formatDuration(entry.deadline - now)}`);
     }
-    lines.push(`${key}: frozen ${formatDuration(entry.deadline - now)}`);
-  }
-  if (lines.length === 0) {
+    if (lines.length === 0) {
+      modelStatusCleanup?.();
+      return;
+    }
+    ctx.ui.setStatus(MODELS_STATUS_KEY, `🚦 Limited: ${lines.join(" | ")}`);
+  } catch {
     modelStatusCleanup?.();
-    return;
   }
-  ctx.ui.setStatus(MODELS_STATUS_KEY, `🚦 Limited: ${lines.join(" | ")}`);
 }
 
 function ensureRateLimitedModelsStatus(): void {
@@ -280,18 +338,23 @@ function ensureRateLimitedModelsStatus(): void {
   modelStatusCleanup = () => {
     clearInterval(ticker);
     modelStatusCleanup = undefined;
-    sharedCtx?.ui.setStatus(MODELS_STATUS_KEY, undefined);
+    try {
+      sharedCtx?.ui.setStatus(MODELS_STATUS_KEY, undefined);
+    } catch {
+      // The extension context can become stale after print-mode session teardown.
+    }
   };
 }
 
-function rememberRateLimit(model: Model<Api>, retryable: RetryableError): void {
+function rememberRateLimit(model: Model<Api>, retryable: RetryableError, errorMessage?: string): void {
   const deadline = Date.now() + retryable.waitMs;
   rateLimitMemory.set(modelKey(model), { reason: retryable.reason, limitedAt: Date.now(), deadline });
-  sharedCtx?.ui.notify(`${formatModel(model)} ${reasonLabel(retryable.reason).toLowerCase()} for ${formatDuration(retryable.waitMs)}.`, "warning");
+  const detail = errorMessage ? ` Error: ${formatErrorDetail(errorMessage)}` : "";
+  sharedCtx?.ui.notify(`${formatModel(model)} ${reasonLabel(retryable.reason).toLowerCase()} for ${formatDuration(retryable.waitMs)}.${detail}`, "warning");
   ensureRateLimitedModelsStatus();
 }
 
-function activeNonRetryableFailure(model: Model<Api>): { failedAt: number; deadline: number; errorMessage: string } | undefined {
+function activeNonRetryableFailure(model: Model<Api>): NonRetryableFailureMemory | undefined {
   const entry = nonRetryableFailureMemory.get(modelKey(model));
   if (!entry) return undefined;
   if (Date.now() >= entry.deadline) {
@@ -309,13 +372,38 @@ function nextAvailableCandidate(current: Model<Api>): FallbackModel | undefined
   return candidateOrder(current).find((entry) => !activeLimit(entry.model) && !hasNonRetryableFailure(entry.model));
 }
 
+function formatErrorDetail(errorMessage: string, maxLength = 500): string {
+  const oneLine = errorMessage.replace(/\s+/g, " ").trim();
+  if (!oneLine) return "unknown error";
+  return oneLine.length > maxLength ? `${oneLine.slice(0, maxLength - 1)}…` : oneLine;
+}
+
 function rememberNonRetryableFailure(model: Model<Api>, errorMessage: string): void {
   const deadline = Date.now() + DEFAULT_NON_RETRYABLE_FREEZE_MS;
   nonRetryableFailureMemory.set(modelKey(model), { failedAt: Date.now(), deadline, errorMessage });
-  sharedCtx?.ui.notify(`${formatModel(model)} failed; freezing it for ${formatDuration(DEFAULT_NON_RETRYABLE_FREEZE_MS)} and trying another configured model if available.`, "warning");
+  sharedCtx?.ui.notify(`${formatModel(model)} failed (${formatErrorDetail(errorMessage)}); freezing it for ${formatDuration(DEFAULT_NON_RETRYABLE_FREEZE_MS)} and trying another configured model if available.`, "warning");
   ensureRateLimitedModelsStatus();
 }
 
+function errorMessageWithCauses(err: unknown): string {
+  const messages: string[] = [];
+  let current: unknown = err;
+  const seen = new Set<unknown>();
+
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    if (current instanceof Error) {
+      if (current.message) messages.push(current.message);
+      current = (current as Error & { cause?: unknown }).cause;
+      continue;
+    }
+    messages.push(String(current));
+    break;
+  }
+
+  return messages.filter(Boolean).join(" Cause: ") || String(err);
+}
+
 function isAbortMessage(msg: string): boolean {
   const lower = msg.toLowerCase();
   return (
@@ -335,6 +423,12 @@ function isAbortErrorEvent(event: AssistantMessageEvent, signal?: AbortSignal):
   return reason === "aborted" || stopReason === "aborted" || isAbortMessage(message);
 }
 
+function recentObservedRateLimitError(maxAgeMs = 60_000): string | undefined {
+  if (!lastObservedRateLimitError) return undefined;
+  if (Date.now() - lastObservedRateLimitError.at > maxAgeMs) return undefined;
+  return lastObservedRateLimitError.message;
+}
+
 function earliestCandidateDeadline(current: Model<Api>): number | undefined {
   const deadlines = candidateOrder(current)
     .map((entry) => activeLimit(entry.model)?.deadline ?? activeNonRetryableFailure(entry.model)?.deadline)
@@ -624,6 +718,19 @@ export function waitForRateLimit(
 
 // ─── Early 429 observer ──────────────────────────────────────────────────────
 
+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}`;
+}
+
 function installFetchRateLimitObserver(): void {
   if (restoreFetch || typeof globalThis.fetch !== "function") return;
 
@@ -634,7 +741,12 @@ function installFetchRateLimitObserver(): void {
     if (activeProviderRequests > 0) {
       if (response.status === 429) {
         const waitMs = retryAfterHeaderMs(response.headers) ?? DEFAULT_RATE_LIMIT_WAIT_MS;
+        const message = await responseErrorMessage(response);
+        lastObservedRateLimitError = { at: Date.now(), message };
         showAmbientRetryStatus("rate-limit", waitMs);
+        if (activeFallbackProviderRequests > 0) {
+          throw new Error(message);
+        }
       } else if (ambientStatusCleanup && response.ok) {
         clearAmbientRetryStatus();
       }
@@ -667,6 +779,7 @@ export function __configureFallbackModelsForTests(
   primaryThinkingLevel = undefined;
   rateLimitMemory.clear();
   nonRetryableFailureMemory.clear();
+  lastObservedRateLimitError = undefined;
   ambientStatusCleanup?.();
   modelStatusCleanup?.();
 }
@@ -716,9 +829,11 @@ export function streamWithLimitsRetry(
 
     while (true) {
       activeProviderRequests++;
+      if (allowFallback) activeFallbackProviderRequests++;
       installFetchRateLimitObserver();
       const buffer: AssistantMessageEvent[] = [];
       let retryable: RetryableError | undefined;
+      let retryableErrorMessage = "";
       let nonRetryableError: { message: string; event?: AssistantMessageEvent } | undefined;
 
       try {
@@ -753,14 +868,22 @@ export function streamWithLimitsRetry(
                 }
 
                 retryable = getRetryableError(errMsg);
-                if (retryable) break;
+                if (retryable) {
+                  retryableErrorMessage = errMsg;
+                  break;
+                }
+                const observedRateLimit = allowFallback ? recentObservedRateLimitError() : undefined;
+                retryable = observedRateLimit ? getRetryableError(observedRateLimit) : undefined;
+                if (retryable && observedRateLimit) {
+                  retryableErrorMessage = observedRateLimit;
+                  break;
+                }
 
                 if (allowFallback) {
                   nonRetryableError = { message: errMsg, event };
                   break;
                 }
 
-                // Non-retryable error without fallbacks: ensure start came first, then forward error.
                 if (buffer.length > 0) {
                   flush(buffer);
                 } else {
@@ -801,9 +924,15 @@ export function streamWithLimitsRetry(
             }
           }
         } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
+          const errMsg = errorMessageWithCauses(err);
           const aborted = Boolean(options?.signal?.aborted) || isAbortMessage(errMsg);
           retryable = !aborted ? getRetryableError(errMsg) : undefined;
+          if (retryable) retryableErrorMessage = errMsg;
+          if (!retryable && allowFallback) {
+            const observedRateLimit = recentObservedRateLimitError();
+            retryable = observedRateLimit ? getRetryableError(observedRateLimit) : undefined;
+            if (retryable && observedRateLimit) retryableErrorMessage = observedRateLimit;
+          }
           if (!retryable) {
             if (allowFallback && !aborted) {
               nonRetryableError = { message: errMsg };
@@ -828,6 +957,7 @@ export function streamWithLimitsRetry(
         }
       } finally {
         activeProviderRequests--;
+        if (allowFallback) activeFallbackProviderRequests--;
         if (activeProviderRequests === 0) {
           clearAmbientRetryStatus();
           restoreFetch?.();
@@ -874,6 +1004,15 @@ export function streamWithLimitsRetry(
       }
 
       if (!retryable) {
+        if (allowFallback && !committed) {
+          const message = "Provider stream ended without a terminal event.";
+          rememberNonRetryableFailure(attempt.model, message);
+          const next = nextAvailableCandidate(attempt.model);
+          if (next) {
+            attempt = next;
+            continue;
+          }
+        }
         if (!committed) {
           if (buffer.length > 0) {
             flush(buffer);
@@ -891,7 +1030,7 @@ export function streamWithLimitsRetry(
       }
 
       if (allowFallback) {
-        rememberRateLimit(attempt.model, retryable);
+        rememberRateLimit(attempt.model, retryable, retryableErrorMessage);
         const next = nextAvailableCandidate(attempt.model);
         if (next) {
           attempt = next;