gsd-pi 2.70.1 → 2.71.0-dev.4c35d99

package/packages/pi-coding-agent/src/core/sdk.test.ts

@@ -0,0 +1,89 @@
+// pi-coding-agent / CredentialCooldownError unit tests
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { CredentialCooldownError } from "./sdk.js";
+
+// ─── CredentialCooldownError ──────────────────────────────────────────────────
+
+describe("CredentialCooldownError", () => {
+	it("is an instance of Error", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.ok(err instanceof Error);
+	});
+
+	it("has name set to CredentialCooldownError", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.equal(err.name, "CredentialCooldownError");
+	});
+
+	it("has code set to AUTH_COOLDOWN", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.equal(err.code, "AUTH_COOLDOWN");
+	});
+
+	it("message includes the provider name", () => {
+		const err = new CredentialCooldownError("openai");
+		assert.ok(
+			err.message.includes("openai"),
+			`Expected message to include provider "openai", got: ${err.message}`,
+		);
+	});
+
+	it("message mentions cooldown window", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.ok(
+			/cooldown window/i.test(err.message),
+			`Expected message to mention "cooldown window", got: ${err.message}`,
+		);
+	});
+
+	it("retryAfterMs is undefined when not provided", () => {
+		const err = new CredentialCooldownError("anthropic");
+		assert.equal(err.retryAfterMs, undefined);
+	});
+
+	it("retryAfterMs holds the provided value when specified", () => {
+		const err = new CredentialCooldownError("anthropic", 30_000);
+		assert.equal(err.retryAfterMs, 30_000);
+	});
+
+	it("retryAfterMs is 0 when explicitly passed as 0", () => {
+		const err = new CredentialCooldownError("anthropic", 0);
+		assert.equal(err.retryAfterMs, 0);
+	});
+
+	it("code property is readonly and always AUTH_COOLDOWN regardless of provider", () => {
+		for (const provider of ["anthropic", "openai", "google", "openrouter"]) {
+			const err = new CredentialCooldownError(provider);
+			assert.equal(err.code, "AUTH_COOLDOWN", `code should be AUTH_COOLDOWN for provider "${provider}"`);
+		}
+	});
+
+	it("different providers produce different messages", () => {
+		const err1 = new CredentialCooldownError("anthropic");
+		const err2 = new CredentialCooldownError("openai");
+		assert.notEqual(err1.message, err2.message);
+	});
+
+	it("can be caught as an Error in a try/catch", () => {
+		let caught: unknown;
+		try {
+			throw new CredentialCooldownError("anthropic", 5_000);
+		} catch (e) {
+			caught = e;
+		}
+		assert.ok(caught instanceof Error);
+		assert.ok(caught instanceof CredentialCooldownError);
+		assert.equal((caught as CredentialCooldownError).retryAfterMs, 5_000);
+	});
+
+	it("code property is detectable via plain object check (cross-process pattern)", () => {
+		const err = new CredentialCooldownError("anthropic", 15_000);
+		// Simulate cross-process serialization: only plain properties survive JSON round-trip
+		const plain = { code: err.code, retryAfterMs: err.retryAfterMs, message: err.message };
+		assert.equal(plain.code, "AUTH_COOLDOWN");
+		assert.equal(plain.retryAfterMs, 15_000);
+	});
+});

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -1,4 +1,24 @@
 import { join } from "node:path";
+
+/**
+ * Structured error thrown when all credentials for a provider are in a
+ * backoff window.  Carries typed metadata so callers (e.g. the auto-loop)
+ * can make informed retry decisions instead of string-matching the message.
+ */
+export class CredentialCooldownError extends Error {
+	readonly code = "AUTH_COOLDOWN" as const;
+	/** Milliseconds until the earliest credential becomes available, or undefined if unknown. */
+	readonly retryAfterMs: number | undefined;
+
+	constructor(provider: string, retryAfterMs?: number) {
+		super(
+			`All credentials for "${provider}" are in a cooldown window. ` +
+				`Please wait a moment and try again, or switch to a different provider.`,
+		);
+		this.name = "CredentialCooldownError";
+		this.retryAfterMs = retryAfterMs;
+	}
+}
 import { Agent, type AgentMessage, type ThinkingLevel } from "@gsd/pi-agent-core";
 import type { Message, Model } from "@gsd/pi-ai";
 import { getAgentDir, getDocsPath } from "../config.js";
@@ -363,8 +383,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 			// Retry key resolution with backoff to handle transient network failures
 			// (e.g., OAuth token refresh failing due to brief connectivity loss).
+			// When credentials are in a cooldown window (e.g., after a 429), wait
+			// for the backoff to expire instead of using fixed delays that are
+			// shorter than the cooldown duration.
 			const maxAttempts = 3;
 			const baseDelayMs = 2000;
+			const maxCooldownWaitMs = 60_000; // Don't wait longer than 60s (skip quota-exhausted 30min backoffs)
 			for (let attempt = 1; attempt <= maxAttempts; attempt++) {
 				const key = await modelRegistry.getApiKeyForProvider(resolvedProvider);
 				if (key) return key;
@@ -379,7 +403,21 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				const isOAuth = model && modelRegistry.isUsingOAuth(model);
 				if (!hasAuth && !isOAuth) break;
 
-				// Wait with exponential backoff before retrying
+				// If credentials are in a cooldown window, wait for the earliest
+				// one to expire rather than using a fixed delay that's too short.
+				const backoffExpiry = modelRegistry.authStorage.getEarliestBackoffExpiry(resolvedProvider);
+				if (backoffExpiry !== undefined) {
+					const waitMs = backoffExpiry - Date.now() + 500; // 500ms buffer
+					if (waitMs > 0 && waitMs <= maxCooldownWaitMs) {
+						await new Promise(resolve => setTimeout(resolve, waitMs));
+						continue; // Retry immediately after cooldown clears
+					}
+					if (waitMs > maxCooldownWaitMs) {
+						break; // Quota-exhausted or very long backoff — don't block
+					}
+				}
+
+				// Standard exponential backoff for non-cooldown transient failures
 				await new Promise(resolve => setTimeout(resolve, baseDelayMs * attempt));
 			}
 
@@ -390,10 +428,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			// the retry handler and creating cascading error entries (#3429).
 			const hasAuth = modelRegistry.authStorage.hasAuth(resolvedProvider);
 			if (hasAuth) {
-				throw new Error(
-					`All credentials for "${resolvedProvider}" are in a cooldown window. ` +
-						`Please wait a moment and try again, or switch to a different provider.`,
-				);
+				const expiry = modelRegistry.authStorage.getEarliestBackoffExpiry(resolvedProvider);
+				const retryAfterMs = expiry !== undefined ? Math.max(0, expiry - Date.now()) : undefined;
+				throw new CredentialCooldownError(resolvedProvider, retryAfterMs);
 			}
 			const model = agent.state.model;
 			const isOAuth = model && modelRegistry.isUsingOAuth(model);
@@ -401,10 +438,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				// If credentials exist but are all in a backoff window (quota / rate-limit),
 				// surface a specific message instead of the misleading "Authentication failed".
 				if (modelRegistry.authStorage.areAllCredentialsBackedOff(resolvedProvider)) {
-					throw new Error(
-						`All credentials for "${resolvedProvider}" are in a cooldown window. ` +
-							`Please wait a moment and try again, or switch to a different provider.`,
-					);
+					const expiry = modelRegistry.authStorage.getEarliestBackoffExpiry(resolvedProvider);
+					const retryAfterMs = expiry !== undefined ? Math.max(0, expiry - Date.now()) : undefined;
+					throw new CredentialCooldownError(resolvedProvider, retryAfterMs);
 				}
 				throw new Error(
 					`Authentication failed for "${resolvedProvider}". ` +

package/packages/pi-coding-agent/src/index.ts

@@ -176,6 +176,7 @@ export { DefaultResourceLoader } from "./core/resource-loader.js";
 export {
 	type CreateAgentSessionOptions,
 	type CreateAgentSessionResult,
+	CredentialCooldownError,
 	// Factory
 	createAgentSession,
 	createBashTool,

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/login-dialog.test.ts

@@ -0,0 +1,24 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { buildAuthUrlPresentation } from "../login-dialog.js";
+
+describe("LoginDialogComponent", () => {
+	test("shows the full OAuth URL when the hyperlink label is truncated", () => {
+		const presentation = buildAuthUrlPresentation(
+			"https://auth.example.com/device?code=ABCD-1234&callback=oauth&state=needs-full-visibility",
+			52,
+		);
+
+		assert.notEqual(
+			presentation.displayUrl,
+			"https://auth.example.com/device?code=ABCD-1234&callback=oauth&state=needs-full-visibility",
+			"narrow terminals should still truncate the hyperlink label",
+		);
+		assert.ok(presentation.fullUrlLines.length > 1, "truncated URLs should expose wrapped full-url lines");
+		assert.match(presentation.fullUrlLines[0] ?? "", /https:\/\/auth\.example\.com\/device\?code=ABCD-1234&/);
+		assert.match(
+			presentation.fullUrlLines[presentation.fullUrlLines.length - 1] ?? "",
+			/state=needs-full-visibility/,
+		);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/components/dynamic-border.ts

@@ -1,8 +1,10 @@
-import type { Component } from "@gsd/pi-tui";
+import type { Component, TUI } from "@gsd/pi-tui";
+import { visibleWidth } from "@gsd/pi-tui";
 import { theme } from "../theme/theme.js";
 
 /**
  * Dynamic border component that adjusts to viewport width.
+ * Supports an optional animated spinner in the label area.
  *
  * Note: When used from extensions loaded via jiti, the global `theme` may be undefined
  * because jiti creates a separate module cache. Always pass an explicit color
@@ -10,11 +12,51 @@ import { theme } from "../theme/theme.js";
  */
 export class DynamicBorder implements Component {
 	private color: (str: string) => string;
+	private label?: string;
+	private spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+	private spinnerIndex = 0;
+	private spinnerInterval: NodeJS.Timeout | null = null;
+	private spinnerColorFn?: (str: string) => string;
 
 	constructor(color: (str: string) => string = (str) => {
 		try { return theme.fg("border", str); } catch { return str; }
-	}) {
+	}, label?: string) {
 		this.color = color;
+		this.label = label;
+	}
+
+	setLabel(label: string | undefined): void {
+		this.label = label;
+	}
+
+	/**
+	 * Start an animated spinner that prepends to the label.
+	 * The spinner rotates every 80ms and triggers a re-render via the TUI.
+	 */
+	startSpinner(ui: TUI, colorFn: (str: string) => string): void {
+		this.stopSpinner();
+		this.spinnerColorFn = colorFn;
+		this.spinnerIndex = 0;
+		this.spinnerInterval = setInterval(() => {
+			this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+			ui.requestRender();
+		}, 80);
+		ui.requestRender();
+	}
+
+	/**
+	 * Stop the spinner animation. The border reverts to a static label.
+	 */
+	stopSpinner(): void {
+		if (this.spinnerInterval) {
+			clearInterval(this.spinnerInterval);
+			this.spinnerInterval = null;
+		}
+		this.spinnerColorFn = undefined;
+	}
+
+	get isSpinning(): boolean {
+		return this.spinnerInterval !== null;
 	}
 
 	invalidate(): void {
@@ -22,6 +64,20 @@ export class DynamicBorder implements Component {
 	}
 
 	render(width: number): string[] {
+		const spinnerPrefix = this.spinnerInterval && this.spinnerColorFn
+			? this.spinnerColorFn(this.spinnerFrames[this.spinnerIndex]) + " "
+			: "";
+
+		if (this.label) {
+			const labelText = ` ${spinnerPrefix}${this.label} `;
+			const labelVisible = visibleWidth(labelText);
+			const leading = "── ";
+			const remaining = Math.max(0, width - labelVisible - leading.length);
+			const trailing = "─".repeat(Math.max(1, remaining));
+			// Color leading and trailing separately so embedded ANSI in the
+			// spinner/label doesn't bleed into the trailing dashes.
+			return [this.color(leading) + labelText + this.color(trailing)];
+		}
 		return [this.color("─".repeat(Math.max(1, width)))];
 	}
 }

package/packages/pi-coding-agent/src/modes/interactive/components/extension-input.ts

@@ -11,6 +11,7 @@ import { keyHint } from "./keybinding-hints.js";
 export interface ExtensionInputOptions {
 	tui?: TUI;
 	timeout?: number;
+	secure?: boolean;
 }
 
 export class ExtensionInputComponent extends Container implements Focusable {
@@ -61,6 +62,7 @@ export class ExtensionInputComponent extends Container implements Focusable {
 		}
 
 		this.input = new Input();
+		this.input.secure = opts?.secure === true;
 		if (placeholder) {
 			this.input.placeholder = placeholder;
 		}

package/packages/pi-coding-agent/src/modes/interactive/components/login-dialog.ts

@@ -7,6 +7,27 @@ import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyHint } from "./keybinding-hints.js";
 
+function wrapPlainText(text: string, width: number): string[] {
+	const lines: string[] = [];
+	const safeWidth = Math.max(1, width);
+	for (let idx = 0; idx < text.length; idx += safeWidth) {
+		lines.push(text.slice(idx, idx + safeWidth));
+	}
+	return lines.length > 0 ? lines : [""];
+}
+
+export function buildAuthUrlPresentation(url: string, terminalColumns: number): {
+	displayUrl: string;
+	fullUrlLines: string[];
+} {
+	const maxUrlWidth = Math.max(20, terminalColumns - 4);
+	const displayUrl = truncateToWidth(url, maxUrlWidth);
+	return {
+		displayUrl,
+		fullUrlLines: displayUrl === url ? [] : wrapPlainText(url, maxUrlWidth),
+	};
+}
+
 /**
  * Login dialog component - replaces editor during OAuth login flow.
  *
@@ -124,14 +145,21 @@ export class LoginDialogComponent extends Container implements Focusable {
 
 		// Truncate the visible URL text so it never wraps (which would break
 		// the OSC 8 hyperlink). The full URL is still the link target.
-		const maxUrlWidth = Math.max(20, this.tui.terminal.columns - 4);
-		const displayUrl = truncateToWidth(url, maxUrlWidth);
+		const { displayUrl, fullUrlLines } = buildAuthUrlPresentation(url, this.tui.terminal.columns);
 		const urlLink = `\x1b]8;;${url}\x07${theme.fg("accent", displayUrl)}\x1b]8;;\x07`;
 		this.contentContainer.addChild(new Text(urlLink, 1, 0));
 
 		const clickHint = process.platform === "darwin" ? "Cmd+click to open" : "Ctrl+click to open";
 		this.contentContainer.addChild(new Text(theme.fg("dim", clickHint), 1, 0));
 
+		if (fullUrlLines.length > 0) {
+			this.contentContainer.addChild(new Spacer(1));
+			this.contentContainer.addChild(new Text(theme.fg("dim", "Full URL:"), 1, 0));
+			for (const line of fullUrlLines) {
+				this.contentContainer.addChild(new Text(theme.fg("dim", line), 1, 0));
+			}
+		}
+
 		if (instructions) {
 			this.contentContainer.addChild(new Spacer(1));
 			this.contentContainer.addChild(new Text(theme.fg("warning", instructions), 1, 0));

package/packages/pi-coding-agent/src/modes/interactive/components/model-selector.ts

@@ -120,7 +120,12 @@ export class ModelSelectorComponent extends Container implements Focusable {
 		this.settingsManager = settingsManager;
 		this.modelRegistry = modelRegistry;
 		this.scopedModels = scopedModels;
-		this.scope = scopedModels.length > 0 ? "scoped" : "all";
+		// Only land in "scoped" view when at least one scoped model has working
+		// auth — otherwise the user would see an empty picker (#unconfigured-models).
+		const hasReadyScopedModel = scopedModels.some((scoped) =>
+			modelRegistry.isProviderRequestReady(scoped.model.provider),
+		);
+		this.scope = hasReadyScopedModel ? "scoped" : "all";
 		this.onSelectCallback = onSelect;
 		this.onCancelCallback = onCancel;
 
@@ -215,12 +220,16 @@ export class ModelSelectorComponent extends Container implements Focusable {
 		}
 
 		this.allModels = this.sortModelsWithinProvider(models);
+		// Scoped models must also be filtered by provider readiness so users
+		// can't pick a scoped model whose provider has no API key / OAuth.
 		this.scopedModelItems = this.sortModelsWithinProvider(
-			this.scopedModels.map((scoped) => ({
-				provider: scoped.model.provider,
-				id: scoped.model.id,
-				model: scoped.model,
-			})),
+			this.scopedModels
+				.filter((scoped) => this.modelRegistry.isProviderRequestReady(scoped.model.provider))
+				.map((scoped) => ({
+					provider: scoped.model.provider,
+					id: scoped.model.id,
+					model: scoped.model,
+				})),
 		);
 		this.activeModels = this.scope === "scoped" ? this.scopedModelItems : this.allModels;
 		this.filteredModels = this.activeModels;

package/packages/pi-coding-agent/src/modes/interactive/components/tool-execution.ts

@@ -325,6 +325,29 @@ export class ToolExecutionComponent extends Container {
 		this.maybeConvertImagesForKitty();
 	}
 
+	/**
+	 * Finalize a pending tool call as failed/interrupted while preserving any streamed partial output.
+	 */
+	completeWithError(message?: string): void {
+		this.isPartial = false;
+		if (this.result) {
+			let content = this.result.content;
+			if (message) {
+				const alreadyHasMessage = content.some((block) => block.type === "text" && block.text === message);
+				if (!alreadyHasMessage) {
+					content = [...content, { type: "text", text: message }];
+				}
+			}
+			this.result = { ...this.result, content, isError: true };
+		} else {
+			this.result = {
+				content: message ? [{ type: "text", text: message }] : [],
+				isError: true,
+			};
+		}
+		this.updateDisplay();
+	}
+
 	/**
 	 * Convert non-PNG images to PNG for Kitty graphics protocol.
 	 * Kitty requires PNG format (f=100), so JPEG/GIF/WebP won't display.
@@ -652,6 +675,12 @@ export class ToolExecutionComponent extends Container {
 			text = `${theme.fg("toolTitle", theme.bold("read"))} ${pathDisplay}`;
 
 			if (this.result) {
+				if (this.result.isError) {
+					const errorText = this.getTextOutput().trim() || "read failed";
+					text += `\n\n${theme.fg("error", errorText)}`;
+					return text;
+				}
+
 				const rawOutput = this.getTextOutput();
 				// Strip hashline prefixes (e.g. "1#BQ:content") for TUI display
 				const output = rawOutput.replace(/^(\s*)\d+#[ZPMQVRWSNKTXJBYH]{2}:/gm, "$1");
@@ -804,6 +833,12 @@ export class ToolExecutionComponent extends Container {
 			}
 
 			if (this.result) {
+				if (this.result.isError) {
+					const errorText = this.getTextOutput().trim() || "ls failed";
+					text += `\n\n${theme.fg("error", errorText)}`;
+					return text;
+				}
+
 				const output = this.getTextOutput().trim();
 				if (output) {
 					const lines = output.split("\n");
@@ -846,6 +881,12 @@ export class ToolExecutionComponent extends Container {
 			}
 
 			if (this.result) {
+				if (this.result.isError) {
+					const errorText = this.getTextOutput().trim() || "find failed";
+					text += `\n\n${theme.fg("error", errorText)}`;
+					return text;
+				}
+
 				const output = this.getTextOutput().trim();
 				if (output) {
 					const lines = output.split("\n");
@@ -892,6 +933,12 @@ export class ToolExecutionComponent extends Container {
 			}
 
 			if (this.result) {
+				if (this.result.isError) {
+					const errorText = this.getTextOutput().trim() || "grep failed";
+					text += `\n\n${theme.fg("error", errorText)}`;
+					return text;
+				}
+
 				const output = this.getTextOutput().trim();
 				if (output) {
 					const lines = output.split("\n");