pi-cliproxyapi-native 0.2.2 → 0.3.0

package/README.md

@@ -17,6 +17,7 @@ Chat uses Pi's native API adapters and model metadata, with availability from yo
 - [Chat models](#chat-models)
   - [Refresh](#refresh)
   - [Wait for quota reset](#wait-for-quota-reset)
+  - [Retry failed turns](#retry-failed-turns)
   - [Compaction](#compaction)
   - [Aliases and model limits](#aliases-and-model-limits)
 - [Backend routes](#backend-routes)
@@ -32,10 +33,10 @@ The extension targets Pi 1.4.0 and CLIProxyAPI 8.0.38, with Node.js 22.19 or new
 If you installed `pi-cliproxy-native`, remove it before installing the renamed package. Both register the same `cliproxyapi` provider.
 
 ```sh
-pi install npm:pi-cliproxyapi-native@0.2.2
+pi install npm:pi-cliproxyapi-native@0.3.0
 ```
 
-For Git installation, use `pi install git:github.com/hawkff/pi-cliproxyapi-native@v0.2.2`. For a local checkout, use `pi install /path/to/pi-cliproxyapi-native`.
+For Git installation, use `pi install git:github.com/hawkff/pi-cliproxyapi-native@v0.3.0`. For a local checkout, use `pi install /path/to/pi-cliproxyapi-native`.
 
 The default proxy address is `http://localhost:8317`. For another address, set the [connection](#connection) before logging in. Restart Pi, then run:
 
@@ -49,7 +50,7 @@ Enter your CLIProxyAPI client key at login. Pi validates it against the proxy be
 
 **Use Pi's built-in `/model` picker for chat.** Choose a `cliproxyapi/` entry there. This extension's `/cli:model` picker is only for CLIProxyAPI image and video models. Selecting a media model does not change chat or generate anything.
 
-Enable only one extension that registers the `cliproxyapi` provider ID. This extension leaves other providers and their hand-written model lists unchanged.
+Enable only one extension that registers the `cliproxyapi` provider ID. Model discovery leaves other providers' model lists unchanged. [Delayed retries](#retry-failed-turns) apply to all providers.
 
 ## Connection
 
@@ -224,6 +225,16 @@ Explicit `api/` routes skip live Claude subscription lookup, even with a managem
 
 Other chat routes retain the response-based fallback: `Retry-After` on HTTP 429 or a recognized quota HTTP 403, or `reset_seconds` in a `model_cooldown` error. Google's native adapter exposes only the structured error body. Those waits share the same seven-day deadline but cannot inspect live weekly usage. Image and video generation still do not retry.
 
+### Retry failed turns
+
+Keep Pi open in terminal or RPC mode to retry failed model turns across all providers, including those outside CLIProxyAPI. After Pi finishes its built-in retries and recovery, the extension waits ten minutes and adds a visible continuation message to resume the unfinished task. Another failed turn starts another ten-minute wait. Successful turns, tool errors, and deliberate cancellations do not start a wait.
+
+Delayed retries are on by default. Use `/auto-retry` to see the status, `/auto-retry off` to cancel the pending retry and disable future ones, or `/auto-retry on` to enable retries for future failures. Reloading the extension restores the default.
+
+Escape or Ctrl+C cancels a pending retry in the terminal. New input, a model change, manual compaction, or session navigation also cancels it. Reloading or closing Pi discards pending retries. One-shot print and JSON runs do not schedule them.
+
+Retries preserve the conversation rather than replaying the original prompt. They do not fix credentials or increase quotas, and resumed work can incur provider charges. Use `/auto-retry off` if a persistent error needs manual correction.
+
 ### Compaction
 
 For automatic compaction and `/compact`, the extension limits medium or higher thinking to low without changing your chat thinking level. It uses Pi's default thinking budgets for these requests. Without an explicit output cap, summaries use the model's output limit. Pi's native adapters reduce the output allowance when needed to fit the remaining context space.

package/extensions/index.ts

@@ -5,6 +5,7 @@ import { PROVIDER_ID, parseConfig } from "../src/config.ts";
 import { registerMediaTools } from "../src/media.ts";
 import { registerModelPicker } from "../src/picker.ts";
 import { createCliproxyProvider } from "../src/provider.ts";
+import { registerAutoRetry } from "../src/retry.ts";
 
 export default async function (pi: ExtensionAPI) {
   let contents = "{}";
@@ -62,6 +63,7 @@ export default async function (pi: ExtensionAPI) {
       compactionSignals,
     ),
   );
+  registerAutoRetry(pi);
   registerMediaTools(pi, config);
   registerModelPicker(pi, config);
   pi.registerCommand("cliproxyapi-refresh", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cliproxyapi-native",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "CLIProxyAPI chat discovery and image/video generation with Pi's native adapters",
   "publishConfig": {
     "access": "public"

package/src/retry.ts

@@ -0,0 +1,99 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey } from "@earendil-works/pi-tui";
+
+export function registerAutoRetry(pi: ExtensionAPI) {
+  let enabled = true;
+  let failed = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let waitingContext: ExtensionContext | undefined;
+  let removeInputListener: (() => void) | undefined;
+
+  function cancel() {
+    clearTimeout(timer);
+    timer = undefined;
+    failed = false;
+    removeInputListener?.();
+    removeInputListener = undefined;
+    waitingContext?.ui.setStatus("cliproxyapi-auto-retry", undefined);
+    waitingContext = undefined;
+  }
+
+  pi.on("agent_end", (event) => {
+    failed = event.messages.findLast((message) => message.role === "assistant")?.stopReason === "error";
+  });
+  pi.on("agent_settled", (event, ctx) => {
+    const retry = enabled && failed && !event.aborted;
+    cancel();
+    // One-shot modes exit after settlement.
+    if (!retry || ctx.mode === "print" || ctx.mode === "json") return;
+
+    const sessionId = ctx.sessionManager.getSessionId();
+    const leafId = ctx.sessionManager.getLeafId();
+    const retryAt = new Date(Date.now() + 10 * 60 * 1000).toLocaleTimeString();
+    waitingContext = ctx;
+    ctx.ui.setStatus("cliproxyapi-auto-retry", `Auto-retry at ${retryAt} · /auto-retry off to cancel`);
+    const notice = `Model request failed. Retrying in 10 minutes at ${retryAt}. Use /auto-retry off to cancel.`;
+    ctx.ui.notify(notice, "warning");
+    if (ctx.mode === "tui") {
+      removeInputListener = ctx.ui.onTerminalInput((data) => {
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) cancel();
+        return undefined;
+      });
+    }
+    timer = setTimeout(
+      () => {
+        cancel();
+        if (
+          !ctx.isIdle() ||
+          ctx.hasPendingMessages() ||
+          ctx.sessionManager.getSessionId() !== sessionId ||
+          ctx.sessionManager.getLeafId() !== leafId
+        )
+          return;
+        pi.sendMessage(
+          {
+            customType: "auto-retry",
+            content: "Retry the failed request and continue the unfinished task from where it stopped.",
+            display: true,
+          },
+          { triggerTurn: true },
+        );
+      },
+      10 * 60 * 1000,
+    );
+    timer.unref();
+  });
+
+  pi.on("input", cancel);
+  pi.on("before_agent_start", cancel);
+  pi.on("agent_start", cancel);
+  pi.on("model_select", cancel);
+  pi.on("user_bash", cancel);
+  pi.on("session_before_compact", (event) => {
+    if (event.reason === "manual") cancel();
+  });
+  pi.on("session_before_switch", cancel);
+  pi.on("session_before_fork", cancel);
+  pi.on("session_before_tree", cancel);
+  pi.on("session_start", cancel);
+  pi.on("session_shutdown", cancel);
+
+  pi.registerCommand("auto-retry", {
+    description: "Control 10-minute retries for failed model requests across all providers",
+    async handler(args, ctx) {
+      const action = args.trim();
+      if (action !== "" && action !== "on" && action !== "off") {
+        ctx.ui.notify("Usage: /auto-retry [on|off]", "error");
+        return;
+      }
+      if (action === "off") {
+        enabled = false;
+        cancel();
+      } else if (action === "on") enabled = true;
+      ctx.ui.notify(
+        `Auto-retry is ${enabled ? "on" : "off"}.${timer ? " A retry is pending." : " No retry is pending."}`,
+        "info",
+      );
+    },
+  });
+}