@arcanemachine/pi-retry 0.2.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# pi-retry
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/arcanemachine/pi-retry/main/logo.jpg" alt="pi-retry logo" width="250" />
+</p>
+
+> Re-prompt or nudge the current turn with a shortcut (default `Ctrl+Alt+R`).
+
+A Pi extension for:
+
+- aborting a slow active response and starting a fresh provider request for the same assistant turn,
+- resuming from an accidentally/intentionally stopped assistant response without typing `continue`, or
+- nudging a new assistant turn from the current context when idle, without typing anything into the editor.
+
+## Why?
+
+A provider may route through multiple upstream providers, and one of them may be slow. By "retrying" the request, the request is re-sent and will hopefully be routed to a faster provider during the retry.
+
+The same shortcut also works while idle: it kicks off a new assistant turn from whatever context is currently there. This is handy for prompting a continuation or follow-up turn without typing an explicit prompt.
+
+## Installation
+
+### From local clone
+
+```bash
+pi install /path/to/pi-retry
+```
+
+### From GitHub
+
+```bash
+pi install git:github.com/arcanemachine/pi-retry
+```
+
+## Configuration
+
+The default shortcut is `Ctrl+Alt+R`. Override it in Pi settings (`.pi/settings.json` in a project or `~/.pi/agent/settings.json` globally):
+
+```json
+{
+  "pi-retry": {
+    "shortcut": "ctrl+alt+r"
+  }
+}
+```
+
+Project settings override global settings.
+
+## Behavior
+
+1. If Pi is streaming, the shortcut aborts the current assistant response and starts a hidden trigger turn.
+2. If Pi is idle, the shortcut sends a hidden trigger turn when all of the following are true:
+   - no pending queued messages
+   - editor input is empty
+3. When an assistant response is aborted (either during retry, or when the leaf was already an aborted assistant message), that aborted message is stripped from provider context for the trigger turn. When there is no aborted assistant message in scope, the trigger turn is sent with the current context unchanged.
+4. In all cases the hidden trigger message itself is also stripped from provider context.
+5. Aborted partial output may still remain visible in session history/UI; it is only stripped from provider context for the trigger turn.

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@arcanemachine/pi-retry",
+  "version": "0.2.0",
+  "description": "Pi extension to re-prompt or nudge the current assistant turn with a shortcut (default Ctrl+Alt+R)",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write src/index.ts package.json README.md AGENTS.md IDEAS.md tests/*.ts",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "pi-package",
+    "retry",
+    "resume",
+    "shortcut"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/arcanemachine/pi-retry/main/logo.jpg"
+  },
+  "author": "Nicholas Moen",
+  "license": "MIT",
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@types/node": "^25.3.0",
+    "prettier": "^3.8.3",
+    "typescript": "^5.7.2",
+    "vitest": "^4.1.6"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arcanemachine/pi-retry.git"
+  },
+  "homepage": "https://github.com/arcanemachine/pi-retry"
+}

package/src/index.ts

@@ -0,0 +1,219 @@
+import type {
+  ContextEvent,
+  ExtensionAPI,
+  ExtensionContext,
+  ExtensionEvent,
+} from "@earendil-works/pi-coding-agent";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type Shortcut = Parameters<ExtensionAPI["registerShortcut"]>[0];
+type ContextMessage = ContextEvent["messages"][number];
+type MessageEndEvent = Extract<ExtensionEvent, { type: "message_end" }>;
+
+const DEFAULT_RETRY_SHORTCUT = "ctrl+alt+r" as Shortcut;
+const RETRY_TRIGGER_TYPE = "pi-retry:trigger";
+const TRIGGER_RETRY_DELAY_MS = 50;
+const TRIGGER_RETRY_ATTEMPTS = 100;
+
+type RetryAction = "retry" | "resume";
+
+let retryPending = false;
+let triggerPending = false;
+const suppressedAssistantTimestamps = new Set<number>();
+
+function readSettings(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object"
+      ? (parsed as Record<string, unknown>)
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function getShortcut(cwd: string): Shortcut {
+  const home = process.env.HOME || homedir();
+  const globalSettings = readSettings(
+    join(home, ".pi", "agent", "settings.json"),
+  );
+  const projectSettings = readSettings(join(cwd, ".pi", "settings.json"));
+
+  const globalConfig = globalSettings["pi-retry"];
+  const projectConfig = projectSettings["pi-retry"];
+
+  const globalShortcut =
+    globalConfig && typeof globalConfig === "object"
+      ? (globalConfig as Record<string, unknown>).shortcut
+      : undefined;
+  const projectShortcut =
+    projectConfig && typeof projectConfig === "object"
+      ? (projectConfig as Record<string, unknown>).shortcut
+      : undefined;
+
+  if (typeof projectShortcut === "string" && projectShortcut.trim()) {
+    return projectShortcut.trim() as Shortcut;
+  }
+
+  if (typeof globalShortcut === "string" && globalShortcut.trim()) {
+    return globalShortcut.trim() as Shortcut;
+  }
+
+  return DEFAULT_RETRY_SHORTCUT;
+}
+
+function isRetryTrigger(message: ContextMessage): boolean {
+  return message.role === "custom" && message.customType === RETRY_TRIGGER_TYPE;
+}
+
+function isSuppressedAssistant(message: ContextMessage): boolean {
+  return (
+    message.role === "assistant" &&
+    message.stopReason === "aborted" &&
+    suppressedAssistantTimestamps.has(message.timestamp)
+  );
+}
+
+function shouldSuppressFromProviderContext(message: ContextMessage): boolean {
+  return isRetryTrigger(message) || isSuppressedAssistant(message);
+}
+
+function scheduleRetryTrigger(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  action: RetryAction,
+  suppressAssistantTimestamp?: number,
+  attempt = 0,
+): void {
+  setTimeout(() => {
+    if (!retryPending) return;
+
+    if (!ctx.isIdle()) {
+      if (attempt >= TRIGGER_RETRY_ATTEMPTS) {
+        retryPending = false;
+        triggerPending = false;
+        ctx.ui.notify("Retry failed: agent did not become idle", "warning");
+        return;
+      }
+
+      scheduleRetryTrigger(
+        pi,
+        ctx,
+        action,
+        suppressAssistantTimestamp,
+        attempt + 1,
+      );
+      return;
+    }
+
+    triggerPending = true;
+    pi.sendMessage(
+      {
+        customType: RETRY_TRIGGER_TYPE,
+        content: "",
+        display: false,
+        details: {
+          timestamp: Date.now(),
+          action,
+          suppressAssistantTimestamp,
+        },
+      },
+      { triggerTurn: true },
+    );
+  }, TRIGGER_RETRY_DELAY_MS);
+}
+
+function handleMessageEnd(event: MessageEndEvent): void {
+  if (!retryPending) return;
+
+  if (
+    event.message.role === "assistant" &&
+    event.message.stopReason === "aborted"
+  ) {
+    suppressedAssistantTimestamps.add(event.message.timestamp);
+  }
+}
+
+function hasEditorText(ctx: ExtensionContext): boolean {
+  return ctx.ui.getEditorText().length > 0;
+}
+
+function getLeafAbortedAssistantTimestamp(
+  ctx: ExtensionContext,
+): number | undefined {
+  const leaf = ctx.sessionManager.getLeafEntry();
+  if (!leaf || leaf.type !== "message") return undefined;
+
+  const { message } = leaf;
+  if (message.role !== "assistant" || message.stopReason !== "aborted") {
+    return undefined;
+  }
+
+  return message.timestamp;
+}
+
+function handleContext(
+  event: ContextEvent,
+): { messages: ContextMessage[] } | undefined {
+  const hasRetryTrigger = event.messages.some(isRetryTrigger);
+  const messages = event.messages.filter(
+    (message) => !shouldSuppressFromProviderContext(message),
+  );
+
+  if (hasRetryTrigger && triggerPending) {
+    retryPending = false;
+    triggerPending = false;
+  }
+
+  if (messages.length === event.messages.length) return undefined;
+  return { messages };
+}
+
+export default function piRetryResponseExtension(pi: ExtensionAPI): void {
+  const retryShortcut = getShortcut(process.cwd());
+
+  pi.on("message_end", handleMessageEnd);
+  pi.on("context", handleContext);
+
+  pi.registerShortcut(retryShortcut, {
+    description: "Retry the in-progress assistant response",
+    handler: (ctx) => {
+      if (retryPending) {
+        ctx.ui.notify("Retry already pending", "info");
+        return;
+      }
+
+      if (!ctx.isIdle()) {
+        retryPending = true;
+        ctx.abort();
+        scheduleRetryTrigger(pi, ctx, "retry");
+        ctx.ui.notify("Retrying response (from last full reply)", "info");
+        return;
+      }
+
+      if (ctx.hasPendingMessages()) {
+        ctx.ui.notify("Resume skipped: pending messages queued", "info");
+        return;
+      }
+
+      if (hasEditorText(ctx)) {
+        ctx.ui.notify("Resume skipped: editor has unsent text", "info");
+        return;
+      }
+
+      const abortedTimestamp = getLeafAbortedAssistantTimestamp(ctx);
+
+      retryPending = true;
+      if (abortedTimestamp !== undefined) {
+        suppressedAssistantTimestamps.add(abortedTimestamp);
+      }
+      scheduleRetryTrigger(pi, ctx, "resume", abortedTimestamp);
+      ctx.ui.notify("Resuming stopped response (from last full reply)", "info");
+    },
+  });
+}