@ryan_nookpi/pi-extension-subagent 0.1.0

package/retry.ts

@@ -0,0 +1,164 @@
+import { getFinalOutput } from "./runner.js";
+import type { SingleResult } from "./types.js";
+
+export const MAX_SUBAGENT_AUTO_RETRIES = 3;
+const RETRY_DELAYS_MS = [2_000, 5_000, 10_000] as const;
+
+export interface RetryDecision {
+	retryable: boolean;
+	reason?: string;
+}
+
+export interface RetryScheduleInfo {
+	retryIndex: number;
+	maxRetries: number;
+	delayMs: number;
+	reason: string;
+}
+
+export interface InvokeWithAutoRetryOptions {
+	invoke: () => Promise<SingleResult>;
+	signal?: AbortSignal;
+	maxRetries?: number;
+	onRetryScheduled?: (info: RetryScheduleInfo) => void | Promise<void>;
+}
+
+function buildFailureText(result: SingleResult): string {
+	return [
+		result.errorMessage,
+		result.stderr,
+		getFinalOutput(result.messages),
+		result.stopReason ? `stopReason=${result.stopReason}` : "",
+	]
+		.filter((value) => typeof value === "string" && value.trim().length > 0)
+		.join("\n");
+}
+
+const TRANSIENT_FAILURE_PATTERNS: RegExp[] = [
+	/\bnetwork\b/i,
+	/\bfetch failed\b/i,
+	/\bconnection reset\b/i,
+	/\bsocket hang up\b/i,
+	/\btemporar(?:y|ily) unavailable\b/i,
+	/\btemporar(?:y|ily) failure\b/i,
+	/\btimeout\b/i,
+	/\btimed out\b/i,
+	/\bETIMEDOUT\b/i,
+	/\bECONNRESET\b/i,
+	/\bECONNREFUSED\b/i,
+	/\bENOTFOUND\b/i,
+	/\bEHOSTUNREACH\b/i,
+	/\b503\b/i,
+	/\b502\b/i,
+	/\b504\b/i,
+	/\b429\b/i,
+	/\brate limit\b/i,
+	/\btoo many requests\b/i,
+	/\boverloaded\b/i,
+	/\bover capacity\b/i,
+	/\bservice unavailable\b/i,
+	/\bserver_error\b/i,
+	/\bserver error\b/i,
+	/an error occurred while processing your request/i,
+	/\bupstream\b/i,
+	/\bTLS\b/i,
+];
+
+function matchesTransientPattern(text: string): boolean {
+	return TRANSIENT_FAILURE_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+export function diagnoseRetryableResult(result: SingleResult): RetryDecision {
+	if (result.stopReason === "aborted") return { retryable: false };
+
+	const finalOutput = getFinalOutput(result.messages).trim();
+	if (result.exitCode === 0 && result.stopReason !== "error" && finalOutput) {
+		return { retryable: false };
+	}
+
+	const failureText = buildFailureText(result);
+	if (!failureText) return { retryable: false };
+	if (!matchesTransientPattern(failureText)) return { retryable: false };
+
+	const firstLine = failureText
+		.split("\n")
+		.map((line) => line.trim())
+		.find(Boolean);
+	return {
+		retryable: true,
+		reason: firstLine || "Transient network/service failure detected.",
+	};
+}
+
+export function diagnoseRetryableError(error: unknown): RetryDecision {
+	const text = error instanceof Error ? `${error.name}: ${error.message}` : String(error ?? "");
+	if (!text || !matchesTransientPattern(text)) return { retryable: false };
+	return { retryable: true, reason: text };
+}
+
+async function waitWithAbort(delayMs: number, signal?: AbortSignal): Promise<void> {
+	if (delayMs <= 0) return;
+	await new Promise<void>((resolve, reject) => {
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const cleanup = () => {
+			if (timer) clearTimeout(timer);
+			if (signal) signal.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(new Error("Subagent retry aborted"));
+		};
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		timer = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, delayMs);
+		if (signal) signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+export async function invokeWithAutoRetry({
+	invoke,
+	signal,
+	maxRetries = MAX_SUBAGENT_AUTO_RETRIES,
+	onRetryScheduled,
+}: InvokeWithAutoRetryOptions): Promise<{ result: SingleResult; retryCount: number }> {
+	let retryCount = 0;
+
+	while (true) {
+		try {
+			const result = await invoke();
+			const retryDecision = diagnoseRetryableResult(result);
+			if (!retryDecision.retryable || retryCount >= maxRetries) {
+				return { result, retryCount };
+			}
+
+			retryCount += 1;
+			const delayMs = RETRY_DELAYS_MS[Math.min(retryCount - 1, RETRY_DELAYS_MS.length - 1)] ?? 2_000;
+			await onRetryScheduled?.({
+				retryIndex: retryCount,
+				maxRetries,
+				delayMs,
+				reason: retryDecision.reason || "Transient network/service failure detected.",
+			});
+			await waitWithAbort(delayMs, signal);
+		} catch (error) {
+			if (signal?.aborted) throw error;
+			const retryDecision = diagnoseRetryableError(error);
+			if (!retryDecision.retryable || retryCount >= maxRetries) throw error;
+
+			retryCount += 1;
+			const delayMs = RETRY_DELAYS_MS[Math.min(retryCount - 1, RETRY_DELAYS_MS.length - 1)] ?? 2_000;
+			await onRetryScheduled?.({
+				retryIndex: retryCount,
+				maxRetries,
+				delayMs,
+				reason: retryDecision.reason || "Transient network/service failure detected.",
+			});
+			await waitWithAbort(delayMs, signal);
+		}
+	}
+}

package/run-utils.ts

@@ -0,0 +1,203 @@
+/**
+ * Shared utilities for formatting and managing subagent command runs.
+ *
+ * Extracted from commands.ts to eliminate duplicated run-summary and
+ * run-history-trimming logic. Output format is intentionally kept
+ * identical to the original inline implementations.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SubagentStore } from "./store.js";
+import type { CommandRunState } from "./types.js";
+import { updateCommandRunsWidget, type WidgetRenderCtx } from "./widget.js";
+
+export interface RemoveRunOptions {
+	ctx?: unknown;
+	pi?: ExtensionAPI;
+	abortIfRunning?: boolean;
+	reason?: string;
+	persistRemovedEntry?: boolean;
+	updateWidget?: boolean;
+	removalReason?: string;
+}
+
+export interface RemoveRunResult {
+	removed: boolean;
+	aborted: boolean;
+}
+
+export interface TrimCommandRunHistoryOptions {
+	maxRuns?: number;
+	ctx?: unknown;
+	pi?: ExtensionAPI;
+	updateWidget?: boolean;
+	removalReason?: string;
+}
+
+export interface ClearFinishedRunsOptions {
+	ctx?: unknown;
+	pi?: ExtensionAPI;
+	updateWidget?: boolean;
+	persistRemovedEntry?: boolean;
+	removalReason?: string;
+}
+
+/**
+ * One-line summary of a command run.
+ *
+ * Format: `#<id> [<status>] <agent> ctx:<contextMode> turn:<turnCount> <elapsed>s tools:<toolCalls>`
+ */
+export function formatCommandRunSummary(run: CommandRunState): string {
+	const elapsedSec = Math.max(0, Math.round(run.elapsedMs / 1000));
+	const contextLabel = run.contextMode === "main" ? "main" : "isolated";
+	return `#${run.id} [${run.status}] ${run.agent} ctx:${contextLabel} turn:${run.turnCount ?? 1} ${elapsedSec}s tools:${run.toolCalls}`;
+}
+
+/**
+ * Return the most recent run matching the optional status filter.
+ * Runs are ordered by descending ID (newest first).
+ * If no filter is given, the newest run overall is returned.
+ */
+export function getLatestRun(
+	store: SubagentStore,
+	statusFilter?: CommandRunState["status"] | CommandRunState["status"][],
+): CommandRunState | undefined {
+	const runs = Array.from(store.commandRuns.values()).sort((a, b) => b.id - a.id);
+	if (!statusFilter) return runs[0];
+	const allowed = Array.isArray(statusFilter) ? statusFilter : [statusFilter];
+	return runs.find((r) => allowed.includes(r.status));
+}
+
+/**
+ * Remove a run from the in-memory store with optional abort/persist side-effects.
+ * This is the single deletion path used by commands/tool/trim logic.
+ * Also cleans up the globalLiveRuns registry to prevent leaks.
+ */
+export function removeRun(store: SubagentStore, runId: number, options: RemoveRunOptions = {}): RemoveRunResult {
+	const run = store.commandRuns.get(runId);
+	if (!run) return { removed: false, aborted: false };
+
+	const abortIfRunning = options.abortIfRunning ?? true;
+	const persistRemovedEntry = options.persistRemovedEntry ?? true;
+	const shouldUpdateWidget = options.updateWidget ?? true;
+	let aborted = false;
+
+	run.removed = true;
+
+	// Abort via globalLiveRuns if the view state lost its controller reference.
+	const globalEntry = store.globalLiveRuns.get(runId);
+	const controller = run.abortController ?? globalEntry?.abortController;
+
+	if (abortIfRunning && run.status === "running" && controller) {
+		const reason = options.reason ?? "Aborting by remove...";
+		run.lastLine = reason;
+		run.lastOutput = reason;
+		controller.abort();
+		aborted = true;
+	}
+
+	run.abortController = undefined;
+	// Do NOT delete from commandRuns — keep the entry with removed:true so that
+	// /sub:history can still display it within the current session.
+	// The entry is re-hydrated from JSONL on session reload via subagent-removed entries.
+	store.globalLiveRuns.delete(runId);
+
+	if (persistRemovedEntry && options.pi && run.deliveryMode !== "humanOnly") {
+		const payload: Record<string, unknown> = { runId };
+		if (options.removalReason) payload.reason = options.removalReason;
+		try {
+			options.pi.appendEntry("subagent-removed", payload);
+		} catch {
+			/* ignore append failures */
+		}
+	}
+
+	if (shouldUpdateWidget) {
+		updateCommandRunsWidget(store, options.ctx as WidgetRenderCtx | undefined);
+	}
+
+	return { removed: true, aborted };
+}
+
+/**
+ * Trim completed/errored command runs so that the store never exceeds
+ * `maxRuns` entries. Oldest finished runs are removed first; running
+ * runs are never evicted.
+ *
+ * Returns the run IDs that were evicted.
+ */
+export function clearFinishedRuns(store: SubagentStore, options: ClearFinishedRunsOptions = {}): number[] {
+	const removedRunIds: number[] = [];
+
+	for (const run of Array.from(store.commandRuns.values())) {
+		if (run.removed || run.status === "running") continue;
+		const globalEntry = store.globalLiveRuns.get(run.id);
+		if (globalEntry?.pendingCompletion) continue;
+
+		const result = removeRun(store, run.id, {
+			ctx: options.ctx,
+			pi: options.pi,
+			abortIfRunning: false,
+			updateWidget: false,
+			persistRemovedEntry: options.persistRemovedEntry,
+			removalReason: options.removalReason,
+		});
+		if (result.removed) removedRunIds.push(run.id);
+	}
+
+	if ((options.updateWidget ?? false) && removedRunIds.length > 0) {
+		updateCommandRunsWidget(store, options.ctx as WidgetRenderCtx | undefined);
+	}
+
+	return removedRunIds;
+}
+
+export function trimCommandRunHistory(
+	store: SubagentStore,
+	options: number | TrimCommandRunHistoryOptions = 10,
+): number[] {
+	const maxRuns = typeof options === "number" ? options : (options.maxRuns ?? 10);
+	const shouldUpdateWidget = typeof options === "number" ? false : (options.updateWidget ?? false);
+
+	const completed = Array.from(store.commandRuns.values())
+		.filter((run) => {
+			if (run.removed) return false; // already removed — skip
+			if (run.status === "running") return false;
+			// Never evict runs with pending cross-session completions.
+			const globalEntry = store.globalLiveRuns.get(run.id);
+			if (globalEntry?.pendingCompletion) return false;
+			return true;
+		})
+		.sort((a, b) => a.id - b.id);
+
+	// Count only active (non-removed) runs — commandRuns.size includes removed entries.
+	let activeCount = Array.from(store.commandRuns.values()).filter((r) => !r.removed).length;
+
+	const removedRunIds: number[] = [];
+	while (activeCount > maxRuns && completed.length > 0) {
+		const oldest = completed.shift();
+		if (!oldest) continue;
+
+		const result = removeRun(store, oldest.id, {
+			ctx: typeof options === "number" ? undefined : options.ctx,
+			pi: typeof options === "number" ? undefined : options.pi,
+			abortIfRunning: false,
+			updateWidget: false,
+			persistRemovedEntry: true,
+			removalReason: typeof options === "number" ? undefined : options.removalReason,
+		});
+		if (result.removed) {
+			removedRunIds.push(oldest.id);
+			activeCount--;
+		}
+	}
+
+	if (shouldUpdateWidget && removedRunIds.length > 0) {
+		updateCommandRunsWidget(
+			store,
+			(typeof options === "number" ? undefined : options.ctx) as WidgetRenderCtx | undefined,
+		);
+	}
+
+	return removedRunIds;
+}