oira666_pi-limits-wait 0.4.7 → 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.7",
+  "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";
@@ -138,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[] = [];
@@ -163,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);
@@ -205,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");
   }
 }