gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

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

@@ -0,0 +1,154 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it, mock, type Mock } from "node:test";
+
+import type { Agent } from "@gsd/pi-agent-core";
+import type { Api, AssistantMessage, Model } from "@gsd/pi-ai";
+
+import { CompactionOrchestrator, type CompactionOrchestratorDeps } from "./compaction-orchestrator.js";
+import { SessionManager } from "./session-manager.js";
+
+function createMockModel(): Model<Api> {
+	return {
+		id: "claude-opus-4-6",
+		name: "Claude Opus 4.6",
+		api: "anthropic-messages" as Api,
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200_000,
+		maxTokens: 16_384,
+	} as Model<Api>;
+}
+
+function createAssistantMessage(
+	stopReason: AssistantMessage["stopReason"],
+	contentText: string,
+): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [{ type: "text", text: contentText }],
+		api: "anthropic-messages",
+		provider: "anthropic",
+		model: "claude-opus-4-6",
+		usage: {
+			input: 100,
+			output: 100,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 200,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason,
+		timestamp: Date.now(),
+		errorMessage: stopReason === "error" ? contentText : undefined,
+	} as AssistantMessage;
+}
+
+function wait(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function createHarness(overrides?: {
+	cancelResult?: boolean;
+	willRetry?: boolean;
+	hasQueuedMessages?: boolean;
+}) {
+	const dir = mkdtempSync(join(tmpdir(), "compaction-orchestrator-test-"));
+	const sessionManager = SessionManager.create(dir, dir);
+	sessionManager.appendMessage({ role: "user", content: "First user message" } as any);
+	sessionManager.appendMessage(createAssistantMessage("stop", "First assistant message"));
+	sessionManager.appendMessage({ role: "user", content: "Second user message" } as any);
+
+	const emittedEvents: Array<Record<string, unknown>> = [];
+	const continueFn = mock.fn(async () => {});
+	const replaceMessages = mock.fn((nextMessages: unknown[]) => {
+		(agent.state.messages as unknown[]) = nextMessages;
+	});
+	const agent = {
+		state: {
+			messages: [
+				{ role: "user", content: "queued follow-up" },
+				createAssistantMessage("error", "context overflow"),
+			],
+		},
+		continue: continueFn,
+		replaceMessages,
+		hasQueuedMessages: () => overrides?.hasQueuedMessages ?? false,
+	} as unknown as Agent;
+
+	const extensionRunner = {
+		hasHandlers: mock.fn(() => true),
+		emit: mock.fn(async () => ({ cancel: overrides?.cancelResult ?? true })),
+	};
+
+	const deps: CompactionOrchestratorDeps = {
+		agent,
+		sessionManager,
+		settingsManager: {
+			getCompactionSettings: () => ({
+				enabled: true,
+				reserveTokens: 16_384,
+				keepRecentTokens: 1,
+			}),
+		} as any,
+		modelRegistry: {
+			isProviderRequestReady: () => true,
+			getApiKey: async () => undefined,
+		} as any,
+		getModel: () => createMockModel(),
+		getSessionId: () => "test-session",
+		getExtensionRunner: () => extensionRunner as any,
+		emit: (event) => emittedEvents.push(event as unknown as Record<string, unknown>),
+		disconnectFromAgent: () => {},
+		reconnectToAgent: () => {},
+		abort: async () => {},
+	};
+
+	return {
+		dir,
+		agent,
+		continueFn,
+		replaceMessages,
+		emittedEvents,
+		extensionRunner,
+		orchestrator: new CompactionOrchestrator(deps),
+		cleanup: () => rmSync(dir, { recursive: true, force: true }),
+	};
+}
+
+describe("CompactionOrchestrator", () => {
+	it("overflow cancel keeps retry intent and resumes the agent (#3971)", async (t) => {
+		const harness = createHarness({ willRetry: true });
+		t.after(harness.cleanup);
+
+		await (harness.orchestrator as any)._runAutoCompaction("overflow", true);
+		await wait(150);
+
+		const endEvent = harness.emittedEvents.find((event) => event.type === "auto_compaction_end");
+		assert.ok(endEvent, "should emit auto_compaction_end");
+		assert.equal(endEvent?.aborted, true, "cancelled compaction should be marked aborted");
+		assert.equal(endEvent?.willRetry, true, "overflow cancel should preserve retry intent");
+		assert.equal(harness.continueFn.mock.callCount(), 1, "overflow cancel should resume the agent");
+		assert.equal(harness.replaceMessages.mock.callCount(), 1, "retry follow-up should trim the error message when present");
+	});
+
+	it("threshold cancel stays non-retrying when no queued messages exist", async (t) => {
+		const harness = createHarness({ willRetry: false, hasQueuedMessages: false });
+		t.after(harness.cleanup);
+
+		await (harness.orchestrator as any)._runAutoCompaction("threshold", false);
+		await wait(150);
+
+		const endEvent = harness.emittedEvents.find((event) => event.type === "auto_compaction_end");
+		assert.ok(endEvent, "should emit auto_compaction_end");
+		assert.equal(endEvent?.aborted, true, "cancelled compaction should be marked aborted");
+		assert.equal(endEvent?.willRetry, false, "threshold cancel should stay non-retrying");
+		assert.equal(harness.continueFn.mock.callCount(), 0, "threshold cancel should not resume the agent without queued work");
+		assert.equal(harness.replaceMessages.mock.callCount(), 0, "non-retry cancel should not trim messages");
+	});
+});

package/packages/pi-coding-agent/src/core/compaction-orchestrator.ts

@@ -333,8 +333,9 @@ export class CompactionOrchestrator {
 						type: "auto_compaction_end",
 						result: undefined,
 						aborted: true,
-						willRetry: false,
+						willRetry,
 					});
+					this._scheduleAutoCompactionFollowup(willRetry);
 					return;
 				}
 
@@ -392,22 +393,7 @@ export class CompactionOrchestrator {
 
 			const result: CompactionResult = { summary, firstKeptEntryId, tokensBefore, details };
 			this._deps.emit({ type: "auto_compaction_end", result, aborted: false, willRetry });
-
-			if (willRetry) {
-				const messages = this._deps.agent.state.messages;
-				const lastMsg = messages[messages.length - 1];
-				if (lastMsg?.role === "assistant" && (lastMsg as AssistantMessage).stopReason === "error") {
-					this._deps.agent.replaceMessages(messages.slice(0, -1));
-				}
-
-				setTimeout(() => {
-					this._deps.agent.continue().catch(() => {});
-				}, 100);
-			} else if (this._deps.agent.hasQueuedMessages()) {
-				setTimeout(() => {
-					this._deps.agent.continue().catch(() => {});
-				}, 100);
-			}
+			this._scheduleAutoCompactionFollowup(willRetry);
 		} catch (error) {
 			// Distinguish the "no usable summary" failure (issue #4665) so the UI
 			// can surface a clearer message than a generic compaction failure.
@@ -430,4 +416,25 @@ export class CompactionOrchestrator {
 			this._autoCompactionAbortController = undefined;
 		}
 	}
+
+	private _scheduleAutoCompactionFollowup(willRetry: boolean): void {
+		if (willRetry) {
+			const messages = this._deps.agent.state.messages;
+			const lastMsg = messages[messages.length - 1];
+			if (lastMsg?.role === "assistant" && (lastMsg as AssistantMessage).stopReason === "error") {
+				this._deps.agent.replaceMessages(messages.slice(0, -1));
+			}
+
+			setTimeout(() => {
+				this._deps.agent.continue().catch(() => {});
+			}, 100);
+			return;
+		}
+
+		if (this._deps.agent.hasQueuedMessages()) {
+			setTimeout(() => {
+				this._deps.agent.continue().catch(() => {});
+			}, 100);
+		}
+	}
 }

package/packages/pi-coding-agent/src/core/extensions/loader.ts

@@ -653,15 +653,72 @@ export function containsTypeScriptSyntax(source: string): boolean {
  * are compiled once and reused across all extensions.
  */
 let _extensionLoaderJiti: ReturnType<typeof createJiti> | null = null;
+// Tracks every extension-module path that jiti has compiled through the shared
+// singleton so resetExtensionLoaderCache() can also evict Node's global
+// require.cache entries for those modules. jiti stores compiled modules under
+// `nativeRequire.cache[filename]` when `moduleCache: true`, so a new singleton
+// still returns the stale cached module on re-import without this eviction.
+const _loadedExtensionPaths = new Set<string>();
+const _extensionRequire = createRequire(import.meta.url);
 
 /**
  * Reset the shared jiti singleton so the next call to getExtensionLoaderJiti()
  * creates a fresh instance.  This prevents memory leaks in long-running daemon
  * processes (every loaded module stays cached forever) and ensures stale modules
  * are not returned when extension source changes on disk.
+ *
+ * #3616: resetting the singleton alone is insufficient — jiti stores compiled
+ * modules in Node's global require.cache when `moduleCache: true`, which is
+ * shared across singletons. We also evict cached entries for every extension
+ * path we've previously loaded so the next import recompiles from disk.
  */
 export function resetExtensionLoaderCache(): void {
 	_extensionLoaderJiti = null;
+	// Build a set of exact cache keys we expect (raw path, resolved path,
+	// realpath) AND a set of (basename, containing-directory) pairs so we
+	// can also catch entries that jiti/Node wrote under a canonicalized
+	// form (Windows drive-letter case, separator swap, UNC prefix, symlink
+	// resolution). require.cache is shared across all createRequire
+	// instances for CJS, so iterating any instance's cache covers jiti's
+	// internal `nativeRequire.cache` writes.
+	const exact = new Set<string>();
+	const signatures = new Set<string>();
+	const makeSignature = (p: string): string => {
+		const normalized = p.replace(/\\/g, "/").toLowerCase();
+		const slash = normalized.lastIndexOf("/");
+		const base = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+		// Use the trailing two path segments as the signature — unique
+		// enough to avoid collisions in typical filesystems while tolerating
+		// drive-letter / separator variations that differ in the prefix.
+		const parent = slash >= 0 ? normalized.slice(0, slash) : "";
+		const parentSlash = parent.lastIndexOf("/");
+		const parentSeg = parentSlash >= 0 ? parent.slice(parentSlash + 1) : parent;
+		return `${parentSeg}/${base}`;
+	};
+	for (const raw of _loadedExtensionPaths) {
+		exact.add(raw);
+		try {
+			exact.add(_extensionRequire.resolve(raw));
+		} catch {
+			// unresolvable — fall through; signature scan may still hit it
+		}
+		try {
+			exact.add(fs.realpathSync(raw));
+		} catch {
+			// file may have been deleted already; ignore
+		}
+		signatures.add(makeSignature(raw));
+	}
+	for (const key of Object.keys(_extensionRequire.cache)) {
+		if (exact.has(key) || signatures.has(makeSignature(key))) {
+			try {
+				delete _extensionRequire.cache[key];
+			} catch {
+				// require.cache is best-effort; ignore failures (e.g. frozen cache).
+			}
+		}
+	}
+	_loadedExtensionPaths.clear();
 }
 
 function getExtensionLoaderJiti() {
@@ -696,6 +753,7 @@ async function loadExtensionModule(extensionPath: string) {
 	const jiti = getExtensionLoaderJiti();
 
 	const module = await jiti.import(extensionPath, { default: true });
+	_loadedExtensionPaths.add(extensionPath);
 	const factory = module as ExtensionFactory;
 	return typeof factory !== "function" ? undefined : factory;
 }

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

@@ -315,8 +315,19 @@ test("LSP integration: typescript-language-server", async (t) => {
 			textDocument: { uri: mathUri, languageId: "typescript", version: 1, text: mathContent },
 		});
 
-		// Give the server time to index
-		await new Promise((r) => setTimeout(r, 3000));
+		// Poll for a published diagnostics notification on main.ts, which
+		// is the observable signal that TypeScript has finished indexing
+		// the opened file. Previous magic-sleep (3000ms) was too short on
+		// slow CI machines and wasteful on fast ones (#4798).
+		const INDEX_DEADLINE_MS = 15_000;
+		const indexDeadline = Date.now() + INDEX_DEADLINE_MS;
+		while (Date.now() < indexDeadline) {
+			const diags = lsp
+				.getNotifications("textDocument/publishDiagnostics")
+				.filter((n) => (n.params as { uri: string }).uri === mainUri);
+			if (diags.length > 0) break;
+			await new Promise((r) => setTimeout(r, 50));
+		}
 
 		// ---- Hover ----
 		await t.test("hover on 'add' call", async () => {
@@ -381,8 +392,28 @@ test("LSP integration: typescript-language-server", async (t) => {
 
 		// ---- Diagnostics (published via notification) ----
 		await t.test("diagnostics for type error", async () => {
-			// Wait a bit more for diagnostics to arrive
-			await new Promise((r) => setTimeout(r, 2000));
+			// Poll for the specific type-error diagnostic on main.ts
+			// instead of sleeping a fixed 2s. tsserver pushes diagnostics
+			// incrementally — we need to wait until at least one diag
+			// contains a type-error signal, not just any diag.
+			const DIAG_DEADLINE_MS = 10_000;
+			const diagDeadline = Date.now() + DIAG_DEADLINE_MS;
+			while (Date.now() < diagDeadline) {
+				const candidates = lsp
+					.getNotifications("textDocument/publishDiagnostics")
+					.filter((n) => (n.params as { uri: string }).uri === mainUri)
+					.flatMap(
+						(n) => (n.params as { diagnostics: Array<{ message: string }> }).diagnostics,
+					);
+				if (
+					candidates.some(
+						(d) => d.message.includes("not assignable") || d.message.includes("Type"),
+					)
+				) {
+					break;
+				}
+				await new Promise((r) => setTimeout(r, 50));
+			}
 
 			const diagNotifications = lsp.getNotifications("textDocument/publishDiagnostics");
 			const mainDiags = diagNotifications.filter(

package/packages/pi-coding-agent/src/core/model-registry-auth-mode.test.ts

@@ -39,6 +39,10 @@ function findModel(registry: ModelRegistry, provider: string, id: string): Model
 	return registry.getAvailable().find((m) => m.provider === provider && m.id === id);
 }
 
+function availableModelIds(registry: ModelRegistry): Set<string> {
+	return new Set(registry.getAvailable().map((model) => `${model.provider}/${model.id}`));
+}
+
 function makeModel(provider: string, id: string, api: string): Model<Api> {
 	return {
 		id,
@@ -93,6 +97,22 @@ function createStreamSpy(): {
 // ─── Registration ─────────────────────────────────────────────────────────────
 
 describe("ModelRegistry authMode — registration", () => {
+	it("includes GPT-5.5 in the authenticated all-models menu backing list", () => {
+		const registry = createInMemoryRegistry({
+			openai: { type: "api_key", key: "sk-test" },
+			"openai-codex": {
+				type: "oauth",
+				access: "codex-access",
+				refresh: "codex-refresh",
+				expires: Date.now() + 60_000,
+			},
+		});
+
+		const ids = availableModelIds(registry);
+		assert.ok(ids.has("openai/gpt-5.5"), "all-models menu backing list should include openai/gpt-5.5");
+		assert.ok(ids.has("openai-codex/gpt-5.5"), "all-models menu backing list should include openai-codex/gpt-5.5");
+	});
+
 	it("registers externalCli provider with streamSimple and without apiKey/oauth", () => {
 		const registry = createRegistry();
 		const spy = createStreamSpy();

package/packages/pi-coding-agent/src/core/resource-loader-cache-reset.test.ts

@@ -1,42 +1,107 @@
-// GSD-2 — Regression test for #3616: reload() must reset jiti extension loader cache
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// Regression test for #3616: DefaultResourceLoader.reload() must invalidate
+// the jiti module cache before loading extensions, so that edits to
+// extension source on disk are picked up on the next reload (not served
+// stale from memory).
+//
+// Verified end-to-end behaviourally: we write a .ts extension that
+// registers a tool whose NAME is a module-scope constant, load it,
+// rewrite the source with a new constant value, reload(), and assert
+// the observable tool name reflects the NEW source. Without jiti cache
+// invalidation, the second reload would re-register the stale name.
 
-import test, { describe } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
 
-const source = readFileSync(
-	join(process.cwd(), "packages/pi-coding-agent/src/core/resource-loader.ts"),
-	"utf-8",
-);
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SettingsManager } from "./settings-manager.js";
+import { resetExtensionLoaderCache } from "./extensions/loader.js";
 
-describe("#3616 — reload() must invalidate jiti module cache", () => {
-	test("resource-loader imports resetExtensionLoaderCache from loader.js", () => {
-		assert.ok(
-			source.includes("resetExtensionLoaderCache"),
-			"resource-loader.ts should import resetExtensionLoaderCache",
-		);
-		assert.ok(
-			source.includes('from "./extensions/loader.js"'),
-			"resetExtensionLoaderCache should be imported from extensions/loader.js",
-		);
+let testDir: string;
+
+function writeExtensionWithToolName(extPath: string, toolName: string): void {
+	// Extension factory signature expected by the loader. Uses `any` so the
+	// test stays decoupled from the ExtensionAPI type shape.
+	writeFileSync(
+		extPath,
+		[
+			`const TOOL_NAME = "${toolName}";`,
+			`export default function activate(api: any) {`,
+			`  api.registerTool({`,
+			`    name: TOOL_NAME,`,
+			`    label: TOOL_NAME,`,
+			`    description: "test tool — source-generated name",`,
+			`    parameters: { type: "object", properties: {}, additionalProperties: false },`,
+			`    execute: async () => ({ content: [], details: undefined }),`,
+			`  });`,
+			`}`,
+			"",
+		].join("\n"),
+	);
+}
+
+describe("#3616 — DefaultResourceLoader.reload() invalidates extension module cache", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "resource-loader-cache-reset-"));
+		// Ensure a clean jiti singleton — prior tests in this process may
+		// have populated it with unrelated entries.
+		resetExtensionLoaderCache();
+	});
+
+	afterEach(() => {
+		resetExtensionLoaderCache();
+		rmSync(testDir, { recursive: true, force: true });
 	});
 
-	test("reload() calls resetExtensionLoaderCache before loadExtensions", () => {
-		const reloadStart = source.indexOf("async reload(): Promise<void>");
-		assert.ok(reloadStart >= 0, "should find reload() method");
-		const reloadBody = source.slice(reloadStart, reloadStart + 4000);
+	it("reload() picks up source edits after the extension has been loaded once", async () => {
+		const agentDir = join(testDir, "agent-home");
+		const extPath = join(testDir, "reload-probe.ts");
 
-		const resetIdx = reloadBody.indexOf("resetExtensionLoaderCache()");
-		assert.ok(resetIdx >= 0, "reload() should call resetExtensionLoaderCache()");
+		// v1 — initial content
+		writeExtensionWithToolName(extPath, "probe_v1");
 
-		const loadIdx = reloadBody.indexOf("loadExtensions(");
-		assert.ok(loadIdx >= 0, "reload() should call loadExtensions");
+		const loader = new DefaultResourceLoader({
+			cwd: testDir,
+			agentDir,
+			settingsManager: SettingsManager.inMemory(),
+			noExtensions: true,
+			noPromptTemplates: true,
+			noThemes: true,
+			additionalExtensionPaths: [extPath],
+		});
 
+		await loader.reload();
+
+		const toolsV1 = [...loader.getExtensions().extensions.flatMap((e) => [...e.tools.keys()])];
+		assert.ok(
+			toolsV1.includes("probe_v1"),
+			`first reload should register probe_v1; got=${JSON.stringify(toolsV1)}`,
+		);
+
+		// v2 — overwrite the source on disk with a different tool name.
+		writeExtensionWithToolName(extPath, "probe_v2");
+		// Bump mtime explicitly so file-stat–based cache strategies (jiti's
+		// moduleCache consults Node's require.cache, which some runtimes
+		// tiebreak on mtime) always see "newer than last seen". On Windows
+		// NTFS + node the default fs mtime resolution can silently collapse
+		// two writes in the same tick to an identical mtime — that fooled
+		// the Windows CI run on #3616.
+		const futureTime = new Date(Date.now() + 5000);
+		utimesSync(extPath, futureTime, futureTime);
+
+		await loader.reload();
+
+		const toolsV2 = [...loader.getExtensions().extensions.flatMap((e) => [...e.tools.keys()])];
+		assert.ok(
+			toolsV2.includes("probe_v2"),
+			`second reload must observe the edited source (probe_v2) — if reload() ` +
+				`fails to reset the jiti cache, the stale module returns probe_v1. got=${JSON.stringify(toolsV2)}`,
+		);
 		assert.ok(
-			resetIdx < loadIdx,
-			"resetExtensionLoaderCache() must be called BEFORE loadExtensions to ensure fresh modules",
+			!toolsV2.includes("probe_v1"),
+			`second reload must NOT still expose the stale probe_v1 name; got=${JSON.stringify(toolsV2)}`,
 		);
 	});
 });

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

@@ -281,7 +281,11 @@ describe("RetryHandler — long-context entitlement 429 (#2803)", () => {
 			assert.equal(result, true, "retry should be initiated");
 
 			handler.abortRetry();
-			await new Promise((resolve) => setTimeout(resolve, 10));
+			// Yield the microtask queue so any synchronous continuation
+			// scheduled by abortRetry() settles before we assert. This is
+			// deterministic — no magic-sleep dependency (#4798 / #4784).
+			await Promise.resolve();
+			await Promise.resolve();
 
 			assert.equal(continueFn.mock.calls.length, 0, "cancelled retry must not continue after explicit abort");
 			const endEvents = emittedEvents.filter((e) => e.type === "auto_retry_end");

package/packages/pi-coding-agent/src/core/retry-handler.ts

@@ -18,6 +18,7 @@ import type { ModelRegistry } from "./model-registry.js";
 import type { SettingsManager } from "./settings-manager.js";
 import { sleep } from "../utils/sleep.js";
 import type { AgentSessionEvent } from "./agent-session.js";
+import { RETRYABLE_ERROR_RE } from "./retryable-error-regex.js";
 
 /** Dependencies injected from AgentSession into RetryHandler */
 export interface RetryHandlerDeps {
@@ -111,14 +112,7 @@ export class RetryHandler {
 		const contextWindow = this._deps.getModel()?.contextWindow ?? 0;
 		if (isContextOverflow(message, contextWindow)) return false;
 
-		const err = message.errorMessage;
-		// "temporarily backed off" is intentionally excluded: it is an internally-
-		// generated error from getApiKey() when credentials are in a backoff window.
-		// Re-entering the retry handler for that message creates a cascade of empty
-		// error entries in the session file, breaking resume (#3429).
-		return /overloaded|rate.?limit|too many requests|402|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|requires more credits|can only afford|insufficient credits|not enough credits|extra usage is required|(?:out of|no) extra usage|third.party.*draw from extra|third.party.*not.*available/i.test(
-			err,
-		);
+		return RETRYABLE_ERROR_RE.test(message.errorMessage);
 	}
 
 	/**

package/packages/pi-coding-agent/src/core/retryable-error-regex.ts

@@ -0,0 +1,18 @@
+/**
+ * Regex matching retryable provider errors — overloaded, rate limits, transient
+ * server/connection failures, credential-backoff, quota/credit issues.
+ *
+ * Kept in its own zero-import module so tests can consume the live pattern
+ * without pulling in the full RetryHandler dependency graph (Agent /
+ * FallbackResolver / ModelRegistry / @gsd/pi-ai …). The test in
+ * `src/resources/extensions/gsd/tests/provider-errors.test.ts` previously
+ * redefined this regex inline, which meant runtime and test could drift
+ * silently on every edit (see #4837).
+ *
+ * "temporarily backed off" is intentionally excluded: it is an internally-
+ * generated error from getApiKey() when credentials are in a backoff window.
+ * Re-entering the retry handler for that message creates a cascade of empty
+ * error entries in the session file, breaking resume (#3429).
+ */
+export const RETRYABLE_ERROR_RE =
+	/overloaded|rate.?limit|too many requests|402|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|requires more credits|can only afford|insufficient credits|not enough credits|extra usage is required|(?:out of|no) extra usage|third.party.*draw from extra|third.party.*not.*available/i;

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

@@ -3,7 +3,8 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { CredentialCooldownError } from "./sdk.js";
+import { canRestoreSessionModel, CredentialCooldownError } from "./sdk.js";
+import type { Model } from "@gsd/pi-ai";
 
 // ─── CredentialCooldownError ──────────────────────────────────────────────────
 
@@ -87,3 +88,26 @@ describe("CredentialCooldownError", () => {
 		assert.equal(plain.retryAfterMs, 15_000);
 	});
 });
+
+describe("canRestoreSessionModel", () => {
+	const model = {
+		provider: "claude-code",
+		id: "claude-sonnet",
+	} as Model<any>;
+
+	it("allows keyless external providers when the provider is request-ready", () => {
+		const registry = {
+			isProviderRequestReady: (provider: string) => provider === "claude-code",
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), true);
+	});
+
+	it("blocks restore when the provider is not request-ready", () => {
+		const registry = {
+			isProviderRequestReady: () => false,
+		};
+
+		assert.equal(canRestoreSessionModel(registry, model), false);
+	});
+});

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

@@ -31,6 +31,13 @@ export class CredentialCooldownError extends Error {
 		this.retryAfterMs = retryAfterMs;
 	}
 }
+
+export function canRestoreSessionModel(
+	modelRegistry: Pick<ModelRegistry, "isProviderRequestReady">,
+	model: Model<any>,
+): boolean {
+	return modelRegistry.isProviderRequestReady(model.provider);
+}
 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";
@@ -262,9 +269,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// If session has data, try to restore model from it
 	if (!model && hasExistingSession && existingSession.model) {
 		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
+			if (restoredModel && canRestoreSessionModel(modelRegistry, restoredModel)) {
+				model = restoredModel;
+			}
 		if (!model) {
 			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
 		}