pi-cliproxyapi-native 0.2.1 → 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)
@@ -27,15 +28,15 @@ Chat uses Pi's native API adapters and model metadata, with availability from yo
 
 ## Install
 
-The extension targets Pi 1.3.0 and CLIProxyAPI 8.0.32, with Node.js 22.19 or newer. Run CLIProxyAPI with your upstream accounts configured before connecting Pi. The extension uses Pi's host-provided packages, adds no runtime dependencies, and needs no compilation.
+The extension targets Pi 1.4.0 and CLIProxyAPI 8.0.38, with Node.js 22.19 or newer. Run CLIProxyAPI with your upstream accounts configured before connecting Pi. The extension uses Pi's host-provided packages, adds no runtime dependencies, and needs no compilation.
 
 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.1
+pi install npm:pi-cliproxyapi-native@0.3.0
 ```
 
-For Git installation, use `pi install git:github.com/hawkff/pi-cliproxyapi-native@v0.2.1`. 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,11 +225,23 @@ 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. If a summary hits its output cap, it retries once with more output room, up to the model's output limit. Pi's native adapters also limit output to the remaining context space. An empty or thinking-only response gets one retry.
+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.
+
+If a caller supplies a smaller cap and the summary hits it, the extension retries once with more output room, up to the model's output limit. An empty or thinking-only response gets one retry, including at the model's output limit.
 
-Pi still selects which messages to summarize and retains recent history, previous summaries, custom instructions, and file tracking. Only the final response reaches the compactor, with usage from both attempts. A second incomplete response fails compaction rather than saving a partial checkpoint. Cancellation, tool calls, and provider failures do not trigger these output retries; Pi keeps its configured transient-error retries and the extension keeps its quota handling.
+Pi still selects which messages to summarize and retains recent history, previous summaries, custom instructions, and file tracking. Only the final response reaches the compactor, with usage from all attempts. Compaction fails rather than saving an incomplete summary. Cancellation, tool calls, and provider failures do not trigger these output retries; Pi keeps its configured transient-error retries and the extension keeps its quota handling.
 
 Authentication failures, exhausted quotas, and inputs that exceed the model's context window still need correction. Run `/compact` after resolving the cause. The extension does not truncate history to force a summary or switch models. CLIProxyAPI's Responses compaction endpoint is separate from Pi's text-summary workflow.
 

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.1",
+  "version": "0.3.0",
   "description": "CLIProxyAPI chat discovery and image/video generation with Pi's native adapters",
   "publishConfig": {
     "access": "public"
@@ -39,9 +39,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.13",
-    "@earendil-works/pi-ai": "^1.3.0",
-    "@earendil-works/pi-coding-agent": "^1.3.0",
-    "@earendil-works/pi-tui": "^1.3.0",
+    "@earendil-works/pi-ai": "^1.4.0",
+    "@earendil-works/pi-coding-agent": "^1.4.0",
+    "@earendil-works/pi-tui": "^1.4.0",
     "@types/node": "^24.13.4",
     "typescript": "5.9.3"
   },

package/src/compaction.ts

@@ -10,7 +10,7 @@ export function withCompactionRecovery(
     return lazyStream(model, async () => ({
       async *[Symbol.asyncIterator]() {
         const limit = model.maxTokens > 0 ? model.maxTokens : 32768;
-        let maxTokens = Math.max(1, Math.min(options.maxTokens ?? 16384, limit));
+        let maxTokens = Math.max(1, Math.min(options.maxTokens ?? limit, limit));
         const reasoning =
           options.reasoning && !["minimal", "low"].includes(options.reasoning) ? "low" : options.reasoning;
         const run = () =>

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",
+      );
+    },
+  });
+}