pi-cursor-sdk 0.1.25 → 0.1.26

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.1.26 - 2026-05-29
+
+### Added
+
+- Cache the discovered Cursor model catalog on disk at `~/.pi/agent/cursor-sdk-model-list.json` (`0600`, keyed by an API-key fingerprint) so warm pi startups skip the live `Cursor.models.list` network round-trip that added several seconds to boot (#78). Tune with `PI_CURSOR_SDK_MODEL_CACHE_TTL_MS` (default 24h) or disable with `PI_CURSOR_SDK_DISABLE_MODEL_CACHE=1`.
+
+### Changed
+
+- Clarify setup docs and runtime auth messages: `pi-cursor-sdk` requires a Cursor SDK API key and does not reuse Cursor Agent CLI/Desktop login or subscription auth.
+- `/cursor-refresh-models` now forces a live catalog refresh, bypassing the on-disk cache and rewriting it. A previously cached catalog is preferred over the bundled fallback when a live refresh fails.
+- Lazy-load the Cursor SDK runtime so warm cached startup paths avoid importing `@cursor/sdk` until live model discovery or a Cursor turn needs it (#100).
+
+### Fixed
+
+- Prevent Cursor SDK `ConnectError: [unauthenticated]` failures from crashing pi as process-level uncaught exceptions; surface them as recoverable Cursor auth errors instead.
+
 ## 0.1.25 - 2026-05-28
 
 ### Fixed

package/README.md

@@ -24,7 +24,7 @@ pi install https://github.com/fitchmultz/pi-cursor-sdk
 pi --model cursor/composer-2.5
 ```
 
-3. In pi, run `/login`, choose `Use an API key`, choose `Cursor`, and paste your Cursor API key.
+3. In pi, run `/login`, choose `Use an API key`, choose `Cursor`, and paste your Cursor SDK API key.
 
 If pi started without a key, run `/cursor-refresh-models` after `/login` to refresh the full live Cursor model catalog without restarting pi. Inside pi, use `/model` to choose another Cursor model.
 
@@ -32,7 +32,7 @@ If pi started without a key, run `/cursor-refresh-models` after `/login` to refr
 
 - Node.js 22.19+
 - pi 0.76.0 or newer
-- a Cursor API key saved through `/login`, available as `CURSOR_API_KEY`, or passed with pi's `--api-key`
+- a Cursor SDK API key saved through `/login`, available as `CURSOR_API_KEY`, or passed with pi's `--api-key`
 
 No global `@cursor/sdk` install is required. This package depends on exact `@cursor/sdk@1.0.15`, so normal package installation brings in the SDK version this extension was built and tested against. This package declares a pi **minimum** of 0.76.0 with no maximum peer version, so users who update pi before this extension is republished are not blocked from trying the existing extension. The current validation baseline is pi 0.77.0 plus Cursor SDK 1.0.15; older pi or Cursor SDK compatibility paths are not maintained.
 
@@ -67,7 +67,11 @@ npm install
 pi -e . --model cursor/composer-2.5
 ```
 
-## Configure your Cursor API key
+## Configure your Cursor SDK API key
+
+`pi-cursor-sdk` passes an explicit API key to the Cursor SDK. It does **not** reuse Cursor Agent CLI login, Cursor Desktop login, or Cursor subscription/OAuth state shown by `agent status`.
+
+Use either a user API key from Cursor Dashboard → Integrations or a service account API key from Team settings. Team Admin API keys are not supported by the Cursor SDK. Then configure the key with one of the methods below.
 
 Preferred setup:
 
@@ -80,11 +84,13 @@ Then, inside pi:
 1. Run `/login`.
 2. Select `Use an API key`.
 3. Select `Cursor`.
-4. Paste your Cursor API key.
+4. Paste your Cursor SDK API key.
 5. The key is saved in pi's native `~/.pi/agent/auth.json`.
 
 If pi started without a key, fallback Cursor models still register so `/login` is reachable. After `/login`, fallback model runs can use the stored key, and `/cursor-refresh-models` refreshes the full live Cursor model catalog discovered from the Cursor SDK without restarting pi.
 
+Note: if `/login` shows `Cursor ✓ key in models.json` but you have not saved a Cursor key and `CURSOR_API_KEY` is unset, that status is a pi auth-status limitation. A real Cursor SDK API key is still required for Cursor runs.
+
 Environment setup:
 
 ```bash
@@ -100,6 +106,18 @@ pi --api-key "your-key" --model cursor/composer-2.5 --cursor-no-fast -p "Say ok
 
 Discovery uses pi's native resolution order for this extension: `--api-key`, the stored `cursor` key in `~/.pi/agent/auth.json`, then `CURSOR_API_KEY`.
 
+### Model catalog cache
+
+To avoid a live `Cursor.models.list` network round-trip on every pi startup, the discovered catalog is cached on disk at `~/.pi/agent/cursor-sdk-model-list.json` (written `0600`, keyed by an API-key fingerprint — the key itself is never stored). Warm startups within the cache TTL skip the network call and avoid loading `@cursor/sdk` until a Cursor turn needs it; `/cursor-refresh-models` always bypasses the cache and refreshes the live catalog. If a refresh fails, a previously cached catalog is preferred over the generic bundled fallback.
+
+```bash
+# Cache lifetime in milliseconds (default 86400000 = 24h).
+PI_CURSOR_SDK_MODEL_CACHE_TTL_MS=3600000 pi --model cursor/composer-2.5
+
+# Disable the cache and always discover live.
+PI_CURSOR_SDK_DISABLE_MODEL_CACHE=1 pi --model cursor/composer-2.5
+```
+
 Do not store the API key in `~/.pi/agent/cursor-sdk.json`. That file is only for non-secret extension state such as Cursor fast defaults. `PATH` is only for executable lookup and should not contain the API key.
 
 ## Verify your setup
@@ -118,9 +136,12 @@ Expected behavior:
 Smoke test:
 
 ```bash
-pi --model cursor/composer-2.5 --cursor-no-fast -p "Reply with: ok"
+pi --model cursor/composer-2.5 --cursor-no-fast --no-session --mode json \
+  -p "Reply exactly PI_CURSOR_MODEL_OK and nothing else."
 ```
 
+Expected: the final assistant text is `PI_CURSOR_MODEL_OK`. If auth is missing or invalid, pi should tell you to configure a Cursor SDK API key via `/login`, `CURSOR_API_KEY`, or `--api-key`.
+
 ## Choosing a model
 
 Choose Cursor models interactively with `/model`, or pass a model on the command line:
@@ -306,7 +327,7 @@ Actual Cursor runs still need a key from `/login`, `CURSOR_API_KEY`, or `--api-k
 
 ### I can see Cursor models, but runs fail
 
-You may be seeing fallback startup models or a missing/invalid key. In interactive pi, run `/login`, choose `Use an API key`, choose `Cursor`, paste the key, then run `/cursor-refresh-models`.
+You may be seeing fallback startup models or a missing/invalid Cursor SDK API key. Cursor Agent CLI/Desktop login is not reused by this extension. In interactive pi, run `/login`, choose `Use an API key`, choose `Cursor`, paste the key, then run `/cursor-refresh-models`.
 
 When a Cursor run fails after auth is configured, pi now surfaces scrubbed provider detail instead of only `Cursor SDK run failed`. Generic SDK failures include safe run metadata such as model id, a short run id prefix, and duration when available. Check the red toast or assistant error message for that detail before retrying.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cursor-sdk",
-	"version": "0.1.25",
+	"version": "0.1.26",
 	"description": "pi provider extension backed by @cursor/sdk local agents",
 	"author": "Mitch Fultz (https://github.com/fitchmultz)",
 	"license": "MIT",

package/src/cursor-agent-message-web-tools.ts

@@ -1,5 +1,6 @@
-import { Agent, type AgentMessage } from "@cursor/sdk";
+import type { AgentMessage } from "@cursor/sdk";
 import { asRecord, getArray, getString, stringifyUnknown } from "./cursor-transcript-utils.js";
+import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 
 const CURSOR_AGENT_MESSAGE_PAGE_LIMIT = 8;
 
@@ -21,6 +22,7 @@ function getOneofCaseValue(value: unknown, caseName: string): unknown {
 }
 
 async function hasCursorAgentMessageAt(agentId: string, cwd: string, offset: number): Promise<boolean> {
+	const { Agent } = await loadCursorSdk();
 	const messages = await Agent.messages.list(agentId, { runtime: "local", cwd, limit: 1, offset });
 	return messages.length > 0;
 }
@@ -46,6 +48,7 @@ export async function loadCursorTranscriptWebToolCallsAfterOffset(options: {
 	offset: number | undefined;
 }): Promise<CursorTranscriptCompletedToolCall[]> {
 	if (options.offset === undefined) return [];
+	const { Agent } = await loadCursorSdk();
 	const messages = await Agent.messages.list(options.agentId, {
 		runtime: "local",
 		cwd: options.cwd,

package/src/cursor-pi-tool-bridge-constants.ts

@@ -0,0 +1,2 @@
+export const MCP_SERVER_NAME = "pi_tools";
+export const MCP_ENDPOINT_ROOT = "/cursor-pi-tool-bridge";

package/src/cursor-pi-tool-bridge-run.ts

@@ -9,6 +9,7 @@ import {
 	ListToolsRequestSchema,
 	type CallToolResult,
 } from "@modelcontextprotocol/sdk/types.js";
+import { MCP_ENDPOINT_ROOT, MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
 import {
 	type CursorPiToolBridgeDiagnosticEvent,
 	type CursorPiToolBridgeLifecycleDiagnosticFields,
@@ -38,8 +39,6 @@ export interface CursorPiToolBridgeRunHost {
 	unregisterRun(pathname: string, run: CursorPiToolBridgeRunImpl): Promise<void>;
 }
 
-export const MCP_SERVER_NAME = "pi_tools";
-export const MCP_ENDPOINT_ROOT = "/cursor-pi-tool-bridge";
 const MCP_SERVER_VERSION = "0.1.0";
 
 interface PendingBridgeCall {

package/src/cursor-pi-tool-bridge-server.ts

@@ -7,7 +7,7 @@ import type {
 	CursorPiToolBridgeSnapshotApi,
 } from "./cursor-pi-tool-bridge-types.js";
 import { isRecord } from "./cursor-pi-tool-bridge-mcp.js";
-import { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
+import type { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
 import {
 	buildCursorPiToolBridgeSnapshot,
 	buildCursorPiToolBridgeSurfaceSignature,
@@ -54,6 +54,7 @@ export class CursorPiToolBridgeRegistry implements CursorPiToolBridge {
 				exposeOverlappingBuiltins: resolveCursorPiToolBridgeBuiltinsEnabled(this.env),
 			})
 			: createEmptySnapshot();
+		const { CursorPiToolBridgeRunImpl } = await import("./cursor-pi-tool-bridge-run.js");
 		const run = new CursorPiToolBridgeRunImpl(this, this.env, snapshot, bridgeEnabled && snapshot.tools.length > 0, options);
 		this.runs.add(run);
 		await run.start();

package/src/cursor-pi-tool-bridge.ts

@@ -13,8 +13,8 @@ import {
 	resolveCursorPiToolBridgeEnabled,
 } from "./cursor-pi-tool-bridge-snapshot.js";
 import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
+import { MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
 import { LOOPBACK_HOST, CursorPiToolBridgeRegistry } from "./cursor-pi-tool-bridge-server.js";
-import { MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-run.js";
 import type {
 	CursorPiToolBridge,
 	CursorPiToolBridgeExtensionApi,

package/src/cursor-provider-errors.ts

@@ -1,12 +1,13 @@
 import type { RunResult } from "@cursor/sdk";
+import { asRecord } from "./cursor-record-utils.js";
 import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 
 export const MISSING_CURSOR_API_KEY_MESSAGE =
-	"Cursor SDK runs require a Cursor API key. Run /login -> Use an API key -> Cursor, set CURSOR_API_KEY before starting pi, or restart pi with --api-key.";
+	"Cursor SDK runs require a Cursor SDK API key. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, set CURSOR_API_KEY before starting pi, or restart pi with --api-key.";
 const GENERIC_CURSOR_SDK_ERROR_MESSAGE =
-	"Cursor SDK request failed. The API key may be missing, invalid, or unauthorized. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
+	"Cursor SDK request failed. The Cursor SDK API key may be missing, invalid, or unauthorized. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
 const AUTH_CURSOR_SDK_ERROR_MESSAGE =
-	"Cursor SDK request failed because the API key may be invalid or unauthorized. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
+	"Cursor SDK request failed because the Cursor SDK API key may be invalid or unauthorized. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
 const NETWORK_CURSOR_SDK_ERROR_MESSAGE =
 	"Cursor SDK request timed out during network I/O. Check your connection and retry; if this keeps happening, try again later or verify Cursor service availability.";
 
@@ -25,7 +26,78 @@ function isKnownGenericRunFailureText(message: string): boolean {
 }
 
 function isLikelyAuthError(message: string): boolean {
-	return /\b(unauthorized|unauthorised|forbidden|invalid api key|invalid key|authentication|auth|401|403)\b/i.test(message);
+	return /\b(unauthenticated|unauthorized|unauthorised|forbidden|invalid api key|invalid key|authentication|auth|401|403)\b/i.test(message);
+}
+
+function getErrorStringField(record: Record<string, unknown> | undefined, key: string): string | undefined {
+	const value = record?.[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+function getErrorStack(error: unknown, record: Record<string, unknown> | undefined): string {
+	return error instanceof Error ? error.stack ?? "" : getErrorStringField(record, "stack") ?? "";
+}
+
+function isConnectError(error: unknown, record: Record<string, unknown> | undefined): boolean {
+	const name = error instanceof Error ? error.name : getErrorStringField(record, "name");
+	return name === "ConnectError";
+}
+
+function isUnauthenticatedConnectCode(code: unknown): boolean {
+	return code === 16 || (typeof code === "string" && /^(?:16|unauthenticated)$/i.test(code));
+}
+
+function getCursorConnectSource(error: unknown, record: Record<string, unknown> | undefined): CursorConnectErrorSource {
+	const stack = getErrorStack(error, record);
+	if (stack.includes("@cursor/sdk")) return "cursor-sdk-stack";
+	const details = Array.isArray(record?.details) ? record.details : [];
+	const hasCursorBackendDetails = details.some((detail) => {
+		const type = getErrorStringField(asRecord(detail), "type");
+		return typeof type === "string" && type.startsWith("aiserver.");
+	});
+	return hasCursorBackendDetails ? "cursor-backend-details" : "generic-connect";
+}
+
+export type CursorConnectErrorSource = "cursor-sdk-stack" | "cursor-backend-details" | "generic-connect";
+
+export type CursorConnectErrorClassification =
+	| { kind: "abort"; source: "cursor-sdk-stack" }
+	| { kind: "unauthenticated"; source: CursorConnectErrorSource };
+
+export function classifyCursorConnectError(error: unknown): CursorConnectErrorClassification | undefined {
+	const record = asRecord(error);
+	if (!isConnectError(error, record)) return undefined;
+
+	const message = error instanceof Error ? error.message : getErrorStringField(record, "message") ?? "";
+	const rawMessage = getErrorStringField(record, "rawMessage") ?? message;
+	const code = record?.code;
+	const cause = asRecord(record?.cause);
+	const causeName = getErrorStringField(cause, "name");
+	const stack = getErrorStack(error, record);
+
+	if (
+		(code === 1 || code === "canceled") &&
+		Boolean(rawMessage && /(?:operation was aborted|canceled)/i.test(rawMessage)) &&
+		(causeName === "AbortError" || /AbortError/.test(stack)) &&
+		stack.includes("@cursor/sdk") &&
+		stack.includes("@connectrpc/connect-node")
+	) {
+		return { kind: "abort", source: "cursor-sdk-stack" };
+	}
+
+	if (isUnauthenticatedConnectCode(code) || isLikelyAuthError(`${message}\n${rawMessage}`)) {
+		return { kind: "unauthenticated", source: getCursorConnectSource(error, record) };
+	}
+
+	return undefined;
+}
+
+export function isCursorSdkAbortConnectError(error: unknown): boolean {
+	return classifyCursorConnectError(error)?.kind === "abort";
+}
+
+export function isUnauthenticatedConnectError(error: unknown): boolean {
+	return classifyCursorConnectError(error)?.kind === "unauthenticated";
 }
 
 function isLikelyNetworkTimeout(message: string): boolean {
@@ -89,8 +161,8 @@ export function sanitizeCursorProviderError(error: unknown, apiKey?: string): st
 	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
 	if (message === MISSING_CURSOR_API_KEY_MESSAGE) return MISSING_CURSOR_API_KEY_MESSAGE;
 	const scrubbed = scrubSensitiveText(message, apiKey).trim();
+	if (isUnauthenticatedConnectError(error) || isLikelyAuthError(scrubbed)) return AUTH_CURSOR_SDK_ERROR_MESSAGE;
 	if (isGenericErrorMessage(scrubbed)) return GENERIC_CURSOR_SDK_ERROR_MESSAGE;
-	if (isLikelyAuthError(scrubbed)) return AUTH_CURSOR_SDK_ERROR_MESSAGE;
 	if (isLikelyNetworkTimeout(scrubbed)) return NETWORK_CURSOR_SDK_ERROR_MESSAGE;
 	return scrubbed || GENERIC_CURSOR_SDK_ERROR_MESSAGE;
 }

package/src/cursor-provider-run-finalizer.ts

@@ -13,7 +13,7 @@ import {
 } from "./cursor-provider-errors.js";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import type { IncompleteCursorToolRunOutcomeInput } from "./cursor-incomplete-tool-visibility.js";
-import type { installCursorSdkAbortErrorSuppression } from "./cursor-sdk-abort-error-guard.js";
+import type { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import type { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
 import type {
@@ -63,7 +63,7 @@ export interface CursorLiveRunCompletion {
 export interface CursorRunFinalizerParams {
 	runnerParams: CursorProviderTurnRunnerParams;
 	sdkEventDebug: () => CursorSdkEventDebugSink | undefined;
-	sdkAbortErrorSuppression: ReturnType<typeof installCursorSdkAbortErrorSuppression>;
+	sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>;
 	resolvedApiKey: () => string | undefined;
 }
 
@@ -145,13 +145,13 @@ export class CursorRunFinalizer {
 			void liveCompletion.waitCompletion
 				.finally(async () => {
 					await this.finalizeSdkEventDebugBestEffort();
-					this.safeCleanup(() => this.params.sdkAbortErrorSuppression.dispose());
+					this.safeCleanup(() => this.params.sdkProcessErrorGuard.dispose());
 				})
 				.catch(() => {});
 			return;
 		}
 		await this.finalizeSdkEventDebugBestEffort();
-		this.safeCleanup(() => this.params.sdkAbortErrorSuppression.dispose());
+		this.safeCleanup(() => this.params.sdkProcessErrorGuard.dispose());
 	}
 
 	private async applyDirectOutcome(
@@ -195,7 +195,7 @@ export class CursorRunFinalizer {
 			await abandonSessionCursorAgent(prepared?.sessionAgentScopeKey);
 		}
 		if (error instanceof CursorLiveRunAbortError) {
-			this.params.sdkAbortErrorSuppression.suppressAbortErrors();
+			this.params.sdkProcessErrorGuard.suppressAbortErrors();
 			this.pushTerminalError(this.params.runnerParams.partial, "aborted", this.abortMessage());
 		} else {
 			this.pushTerminalError(

package/src/cursor-provider-turn-finalize.ts

@@ -1,4 +1,3 @@
-import { createAgentPlatform } from "@cursor/sdk";
 import type { SDKAgent } from "@cursor/sdk";
 import { loadCursorTranscriptWebToolCallsAfterOffset } from "./cursor-agent-message-web-tools.js";
 import { getCheckpointContextWindow, saveCachedContextWindow } from "./context-window-cache.js";
@@ -10,9 +9,11 @@ import {
 	type CursorRunOutcome,
 } from "./cursor-provider-run-outcome.js";
 import type { CursorProviderTurnPrepareResult } from "./cursor-provider-turn-types.js";
+import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 
 export async function cacheSdkContextWindow(agentId: string, modelId: string): Promise<void> {
 	try {
+		const { createAgentPlatform } = await loadCursorSdk();
 		const platform = await createAgentPlatform();
 		const checkpoint = await platform.checkpointStore.loadLatest(agentId);
 		const contextWindow = getCheckpointContextWindow(checkpoint);

package/src/cursor-provider-turn-prepare.ts

@@ -1,5 +1,4 @@
 import type { SimpleStreamOptions } from "@earendil-works/pi-ai";
-import { Agent } from "@cursor/sdk";
 import { installCursorMcpToolTimeoutOverride } from "./cursor-mcp-timeout-override.js";
 import { installCursorSdkOutputFilter, suppressCursorSdkOutput } from "./cursor-sdk-output-filter.js";
 import {
@@ -26,6 +25,7 @@ import { isCursorNativeToolDisplayRuntimeEnabled } from "./cursor-native-tool-di
 import { MISSING_CURSOR_API_KEY_MESSAGE } from "./cursor-provider-errors.js";
 import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
 import { resolveCursorApiKey } from "./cursor-provider-turn-api-key.js";
+import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import type {
 	CursorProviderTurnPrepareResult,
 	CursorProviderTurnRunnerParams,
@@ -56,6 +56,7 @@ export async function prepareCursorProviderTurn(
 		const agentMode = getEffectiveCursorAgentMode();
 		const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
 		const settingSources = getEffectiveCursorSettingSources();
+		const { Agent } = await loadCursorSdk();
 
 		installCursorMcpToolTimeoutOverride();
 		restoreCursorSdkOutputFilter = installCursorSdkOutputFilter();

package/src/cursor-provider-turn-runner.ts

@@ -1,7 +1,7 @@
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import { drainExistingCursorLiveRunBeforeSend } from "./cursor-provider-live-run-drain.js";
 import { getCursorSessionCwd } from "./cursor-session-cwd.js";
-import { installCursorSdkAbortErrorSuppression } from "./cursor-sdk-abort-error-guard.js";
+import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
 import {
@@ -41,7 +41,7 @@ export class CursorProviderTurnRunner {
 		discardIncompleteToolsFromPrepared(prepared, outcome);
 	}
 
-	async run(sdkAbortErrorSuppression: ReturnType<typeof installCursorSdkAbortErrorSuppression>): Promise<void> {
+	async run(sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>): Promise<void> {
 		const { stream, partial, model, context, options, sdkEventDebugRef } = this.params;
 		let prepared: CursorProviderTurnPrepareResult | undefined;
 		let sendResult: CursorProviderTurnSendResult | undefined;
@@ -49,7 +49,7 @@ export class CursorProviderTurnRunner {
 		const runFinalizer = new CursorRunFinalizer({
 			runnerParams: this.params,
 			sdkEventDebug: () => this.sdkEventDebug,
-			sdkAbortErrorSuppression,
+			sdkProcessErrorGuard,
 			resolvedApiKey: () => this.resolvedApiKey,
 		});
 
@@ -84,7 +84,7 @@ export class CursorProviderTurnRunner {
 				params: this.params,
 				prepared,
 				sdkEventDebug: this.sdkEventDebug,
-				sdkAbortErrorSuppression,
+				sdkProcessErrorGuard,
 				throwIfAborted: () => this.throwIfAborted(),
 			});
 			const { send } = sendResult;
@@ -131,7 +131,7 @@ export class CursorProviderTurnRunner {
 		const runFinalizer = new CursorRunFinalizer({
 			runnerParams: this.params,
 			sdkEventDebug: () => this.sdkEventDebug,
-			sdkAbortErrorSuppression: installCursorSdkAbortErrorSuppression(),
+			sdkProcessErrorGuard: installCursorSdkProcessErrorGuard(),
 			resolvedApiKey: () => this.resolvedApiKey,
 		});
 		await runFinalizer.applyTerminalEvent({ kind: "error", prepared: undefined, error });

package/src/cursor-provider-turn-send.ts

@@ -2,7 +2,7 @@ import type { SendOptions } from "@cursor/sdk";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import { getCursorAgentMessageOffset } from "./cursor-provider-turn-message-offset.js";
-import type { installCursorSdkAbortErrorSuppression } from "./cursor-sdk-abort-error-guard.js";
+import type { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import type {
 	CursorProviderTurnRunnerParams,
 	CursorProviderTurnPrepareResult,
@@ -14,12 +14,12 @@ export interface SendCursorProviderTurnParams {
 	params: CursorProviderTurnRunnerParams;
 	prepared: CursorProviderTurnPrepareResult;
 	sdkEventDebug: CursorSdkEventDebugSink | undefined;
-	sdkAbortErrorSuppression: ReturnType<typeof installCursorSdkAbortErrorSuppression>;
+	sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>;
 	throwIfAborted: () => void;
 }
 
 export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnParams): Promise<CursorProviderTurnSendResult> {
-	const { params, prepared, sdkEventDebug, sdkAbortErrorSuppression, throwIfAborted } = sendParams;
+	const { params, prepared, sdkEventDebug, sdkProcessErrorGuard, throwIfAborted } = sendParams;
 	const { options } = params;
 	const { agent, cwd, payload, meta, runtime } = prepared;
 	const { turnCoordinator, liveRun } = runtime;
@@ -27,7 +27,7 @@ export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnP
 	let completed = false;
 	let sdkRun: Awaited<ReturnType<typeof agent.send>> | null = null;
 	const abortListener = () => {
-		sdkAbortErrorSuppression.suppressAbortErrors();
+		sdkProcessErrorGuard.suppressAbortErrors();
 		liveRun?.bridgeRun?.cancel("Cursor SDK run aborted");
 		if (sdkRun) {
 			sdkRun.cancel().catch(() => {});
@@ -84,7 +84,7 @@ export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnP
 		});
 		if (liveRun) cursorLiveRuns.attachSdkRun(liveRun, run);
 		if (options?.signal?.aborted) {
-			sdkAbortErrorSuppression.suppressAbortErrors();
+			sdkProcessErrorGuard.suppressAbortErrors();
 			liveRun?.bridgeRun?.cancel("Cursor SDK run aborted");
 			await run.cancel().catch(() => {});
 			throw new CursorLiveRunAbortError();

package/src/cursor-provider.ts

@@ -18,7 +18,7 @@ import {
 import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import { disposeAllSessionCursorAgents } from "./cursor-session-agent.js";
 import { attachCursorSdkEventDebugPiStreamTap, type CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
-import { installCursorSdkAbortErrorSuppression } from "./cursor-sdk-abort-error-guard.js";
+import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import { sanitizeCursorProviderError } from "./cursor-provider-errors.js";
 import { CursorProviderTurnRunner, resolveCursorApiKey } from "./cursor-provider-turn-runner.js";
 
@@ -53,7 +53,7 @@ export function streamCursor(
 
 	(async () => {
 		const partial = makeInitialMessage(model);
-		const sdkAbortErrorSuppression = installCursorSdkAbortErrorSuppression();
+		const sdkProcessErrorGuard = installCursorSdkProcessErrorGuard();
 
 		const runner = new CursorProviderTurnRunner({
 			model,
@@ -65,7 +65,7 @@ export function streamCursor(
 		});
 
 		try {
-			await runner.run(sdkAbortErrorSuppression);
+			await runner.run(sdkProcessErrorGuard);
 		} catch (error) {
 			await runner.handleOuterCatch(error);
 		}

package/src/cursor-sdk-process-error-guard.ts

@@ -0,0 +1,99 @@
+import { classifyCursorConnectError, isCursorSdkAbortConnectError } from "./cursor-provider-errors.js";
+
+interface CursorSdkProcessErrorGuardToken {
+	suppressAbortErrors: boolean;
+}
+
+export interface CursorSdkProcessErrorGuard {
+	suppressAbortErrors(): void;
+	dispose(): void;
+}
+
+type GenericProcessEmit = (event: string | symbol, ...args: unknown[]) => boolean;
+
+// The local Cursor SDK can surface some ConnectRPC failures as process-level
+// uncaught exceptions/unhandled rejections even when run.wait()/run.cancel() is awaited.
+// Keep suppression scoped to active Cursor provider turns and tightly matched SDK shapes.
+const activeProviderTurns = new Set<CursorSdkProcessErrorGuardToken>();
+let originalProcessEmit: GenericProcessEmit | undefined;
+let captureCallbackInstalled = false;
+
+function hasActiveAbortSuppression(): boolean {
+	for (const turn of activeProviderTurns) {
+		if (turn.suppressAbortErrors) return true;
+	}
+	return false;
+}
+
+function isCursorProvenance(source: string): boolean {
+	return source === "cursor-sdk-stack" || source === "cursor-backend-details";
+}
+
+function shouldSuppressProcessError(event: string | symbol, args: readonly unknown[]): boolean {
+	if (event !== "uncaughtException" && event !== "unhandledRejection") return false;
+	const error = args[0];
+	const classification = classifyCursorConnectError(error);
+	if (!classification) return false;
+	if (classification.kind === "abort") return hasActiveAbortSuppression();
+	return activeProviderTurns.size > 0 && isCursorProvenance(classification.source);
+}
+
+function installProcessEmitPatch(): void {
+	if (originalProcessEmit) return;
+	originalProcessEmit = process.emit.bind(process) as GenericProcessEmit;
+	process.emit = function patchedCursorSdkProcessErrorEmit(this: NodeJS.Process, event: string | symbol, ...args: unknown[]): boolean {
+		if (shouldSuppressProcessError(event, args)) return true;
+		return originalProcessEmit!(event, ...args);
+	} as typeof process.emit;
+}
+
+function installCaptureCallbackIfAvailable(): void {
+	if (captureCallbackInstalled || process.hasUncaughtExceptionCaptureCallback()) return;
+	process.setUncaughtExceptionCaptureCallback((error: Error) => {
+		if (shouldSuppressProcessError("uncaughtException", [error])) return;
+		uninstallCaptureCallbackIfIdle(true);
+		if (originalProcessEmit?.("uncaughtException", error)) return;
+		throw error;
+	});
+	captureCallbackInstalled = true;
+}
+
+function uninstallCaptureCallbackIfIdle(force = false): void {
+	if (!captureCallbackInstalled) return;
+	if (!force && activeProviderTurns.size > 0) return;
+	process.setUncaughtExceptionCaptureCallback(null);
+	captureCallbackInstalled = false;
+}
+
+function uninstallProcessEmitPatchIfIdle(): void {
+	if (activeProviderTurns.size > 0 || !originalProcessEmit) return;
+	uninstallCaptureCallbackIfIdle();
+	process.emit = originalProcessEmit as typeof process.emit;
+	originalProcessEmit = undefined;
+}
+
+export const __testUtils = {
+	activeProviderTurnCount: (): number => activeProviderTurns.size,
+};
+
+export { isCursorSdkAbortConnectError };
+
+export function installCursorSdkProcessErrorGuard(): CursorSdkProcessErrorGuard {
+	installProcessEmitPatch();
+	installCaptureCallbackIfAvailable();
+	const token: CursorSdkProcessErrorGuardToken = { suppressAbortErrors: false };
+	activeProviderTurns.add(token);
+	let disposed = false;
+	return {
+		suppressAbortErrors(): void {
+			if (disposed) return;
+			token.suppressAbortErrors = true;
+		},
+		dispose(): void {
+			if (disposed) return;
+			disposed = true;
+			activeProviderTurns.delete(token);
+			uninstallProcessEmitPatchIfIdle();
+		},
+	};
+}

package/src/cursor-sdk-runtime.ts

@@ -0,0 +1,5 @@
+export type CursorSdkModule = typeof import("@cursor/sdk");
+
+export async function loadCursorSdk(): Promise<CursorSdkModule> {
+	return import("@cursor/sdk");
+}

package/src/cursor-session-agent.ts

@@ -6,7 +6,6 @@ import type {
 	SessionTreeEvent,
 } from "@earendil-works/pi-coding-agent";
 import { createHash } from "node:crypto";
-import { Agent } from "@cursor/sdk";
 import type { AgentModeOption, ModelSelection, SDKAgent, SettingSource } from "@cursor/sdk";
 import type { Context } from "@earendil-works/pi-ai";
 import {
@@ -17,6 +16,7 @@ import {
 import { computeCursorContextFingerprint } from "./context.js";
 import { getCursorSessionScopeKey, onCursorSessionScopeKeyChange } from "./cursor-session-scope.js";
 import type { CursorSdkEventDebugRecorder } from "./cursor-sdk-event-debug.js";
+import { loadCursorSdk, type CursorSdkModule } from "./cursor-sdk-runtime.js";
 
 export interface SessionCursorAgentSendState {
 	bootstrapped: boolean;
@@ -109,7 +109,7 @@ interface SessionCursorAgentCreateParams {
 	settingSources?: SettingSource[];
 	onBridgeToolRequest?: (request: CursorPiBridgeToolRequest) => void;
 	debugRecorder?: CursorSdkEventDebugRecorder;
-	createAgent?: typeof Agent.create;
+	createAgent?: CursorSdkModule["Agent"]["create"];
 }
 
 interface CursorSessionAgentExtensionApi {
@@ -377,7 +377,7 @@ async function createSessionAgentEntry(
 	}
 
 	const resolvedPoolKey = buildSessionAgentPoolKey(scopeKey, params);
-	const createAgent = params.createAgent ?? Agent.create;
+	const createAgent = params.createAgent ?? (await loadCursorSdk()).Agent.create;
 	let agent: SDKAgent;
 	try {
 		agent = await createAgent({

package/src/index.ts

@@ -67,6 +67,7 @@ export default async function (pi: CursorExtensionApi) {
 		handler: async (_args, ctx) => {
 			let refreshFallbackIssue: CursorModelFallbackIssue | undefined;
 			const refreshedModels = await discoverModels({
+				forceRefresh: true,
 				onFallback: (issue) => {
 					refreshFallbackIssue = issue;
 				},
@@ -74,7 +75,7 @@ export default async function (pi: CursorExtensionApi) {
 			registerCursorProvider(pi, refreshedModels);
 			if (!ctx.hasUI) return;
 			if (refreshFallbackIssue) {
-				ctx.ui.notify(`Cursor model catalog refresh still using fallback models: ${refreshFallbackIssue.message}`, "warning");
+				ctx.ui.notify(`Cursor model catalog refresh did not use a live catalog: ${refreshFallbackIssue.message}`, "warning");
 			} else {
 				ctx.ui.notify(`Cursor model catalog refreshed with ${refreshedModels.length} model${refreshedModels.length === 1 ? "" : "s"}.`, "info");
 			}

package/src/model-discovery.ts

@@ -1,4 +1,3 @@
-import { Cursor } from "@cursor/sdk";
 import type {
 	ModelListItem,
 	ModelParameterDefinition,
@@ -8,19 +7,26 @@ import type {
 import { AuthStorage, type ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import type { ModelThinkingLevel, ThinkingLevelMap } from "@earendil-works/pi-ai";
 import { loadContextWindowCache } from "./context-window-cache.js";
+import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import { CURSOR_API_KEY_ENV_VAR, resolveCursorApiKey } from "./cursor-api-key.js";
 import { FALLBACK_MODEL_ITEMS } from "./cursor-fallback-models.generated.js";
+import {
+	fingerprintApiKey,
+	loadAnyCachedModelCatalog,
+	loadFreshCachedModels,
+	saveModelListCache,
+} from "./model-list-cache.js";
 
 const CURSOR_PROVIDER_ID = "cursor";
 const FALLBACK_CONTEXT_WINDOW = 128000;
 const FALLBACK_MAX_TOKENS = 16384;
 const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 const TEXT_AND_IMAGE_INPUT: ProviderModelConfig["input"] = ["text", "image"];
-const AUTH_SETUP_HINT = "/login (Use an API key -> Cursor), CURSOR_API_KEY, or --api-key";
+const AUTH_SETUP_HINT = "/login (Use an API key -> Cursor), CURSOR_API_KEY, or --api-key with a Cursor SDK API key; Cursor Agent CLI/Desktop login is not reused";
 const CATALOG_REFRESH_HINT =
 	"After adding auth to an already-started pi session, run /cursor-refresh-models to refresh the full live Cursor model catalog without restarting pi.";
 
-export type CursorModelFallbackReason = "missing-api-key" | "discovery-failed" | "empty-model-list";
+export type CursorModelFallbackReason = "missing-api-key" | "discovery-failed" | "empty-model-list" | "cached-after-error";
 
 export interface CursorModelFallbackIssue {
 	reason: CursorModelFallbackReason;
@@ -30,6 +36,10 @@ export interface CursorModelFallbackIssue {
 
 export interface DiscoverModelsOptions {
 	onFallback?: (issue: CursorModelFallbackIssue) => void;
+	// Bypass the on-disk model cache and always hit the live catalog. Used by the
+	// /cursor-refresh-models command; the startup path leaves this false so warm
+	// boots skip the slow network round-trip.
+	forceRefresh?: boolean;
 }
 
 function getCliApiKeyFromArgv(argv: string[] = process.argv): string | undefined {
@@ -442,9 +452,20 @@ export async function discoverModels(options: DiscoverModelsOptions = {}): Promi
 		});
 	}
 
+	const keyFingerprint = fingerprintApiKey(apiKey);
+
+	if (!options.forceRefresh) {
+		const cachedModels = loadFreshCachedModels(keyFingerprint);
+		if (cachedModels && cachedModels.length > 0) {
+			return registerModelItems(cachedModels);
+		}
+	}
+
 	try {
+		const { Cursor } = await loadCursorSdk();
 		const models = await Cursor.models.list({ apiKey });
 		if (models.length > 0) {
+			saveModelListCache(keyFingerprint, models);
 			return registerModelItems(models);
 		}
 		return useFallbackModels(options, {
@@ -453,6 +474,18 @@ export async function discoverModels(options: DiscoverModelsOptions = {}): Promi
 		});
 	} catch (error) {
 		const errorMessage = sanitizeDiscoveryError(error, apiKey);
+		// Prefer a previously cached catalog over the generic bundled fallback when
+		// a live refresh fails (e.g. transient network/auth errors), but keep the
+		// provenance visible so refresh commands do not claim a live refresh worked.
+		const cachedCatalog = loadAnyCachedModelCatalog(keyFingerprint);
+		if (cachedCatalog && cachedCatalog.models.length > 0) {
+			options.onFallback?.({
+				reason: "cached-after-error",
+				message: `Cursor model discovery failed; using cached Cursor model catalog from ${new Date(cachedCatalog.fetchedAt).toISOString()}. ${errorMessage}`,
+				errorMessage,
+			});
+			return registerModelItems(cachedCatalog.models);
+		}
 		return useFallbackModels(options, {
 			reason: "discovery-failed",
 			message: `Cursor model discovery failed${errorMessage ? `: ${errorMessage}` : ""}. Using fallback Cursor models; verify ${AUTH_SETUP_HINT}. ${CATALOG_REFRESH_HINT}`,

package/src/model-list-cache.ts

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { ModelListItem } from "@cursor/sdk";
+import { parseEnvBoolean } from "./cursor-env-boolean.js";
+
+const MODEL_LIST_CACHE_FILE = "cursor-sdk-model-list.json";
+const MODEL_LIST_CACHE_VERSION = 1;
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DISABLE_ENV_VAR = "PI_CURSOR_SDK_DISABLE_MODEL_CACHE";
+const TTL_ENV_VAR = "PI_CURSOR_SDK_MODEL_CACHE_TTL_MS";
+
+interface ModelListCacheFile {
+	version: number;
+	fetchedAt: number;
+	keyFingerprint: string;
+	models: ModelListItem[];
+}
+
+export interface CachedModelList {
+	fetchedAt: number;
+	models: ModelListItem[];
+}
+
+function getCachePath(): string {
+	return join(getAgentDir(), MODEL_LIST_CACHE_FILE);
+}
+
+export function isModelCacheDisabled(): boolean {
+	return parseEnvBoolean(process.env[DISABLE_ENV_VAR], false);
+}
+
+export function getModelCacheTtlMs(): number {
+	const raw = process.env[TTL_ENV_VAR];
+	if (raw === undefined) return DEFAULT_TTL_MS;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_TTL_MS;
+	return parsed;
+}
+
+// Fingerprint the API key so a key change invalidates the cache, without ever
+// persisting the key itself.
+export function fingerprintApiKey(apiKey: string): string {
+	return createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
+}
+
+function readCacheFile(): ModelListCacheFile | undefined {
+	const path = getCachePath();
+	if (!existsSync(path)) return undefined;
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8")) as ModelListCacheFile;
+		if (
+			parsed.version !== MODEL_LIST_CACHE_VERSION ||
+			typeof parsed.fetchedAt !== "number" ||
+			typeof parsed.keyFingerprint !== "string" ||
+			!Array.isArray(parsed.models)
+		) {
+			return undefined;
+		}
+		return parsed;
+	} catch {
+		return undefined;
+	}
+}
+
+// Return cached models only when caching is enabled, the key matches, and the
+// entry is within the TTL. Used on the hot startup path to skip the network.
+export function loadFreshCachedModels(keyFingerprint: string, now: number = Date.now()): ModelListItem[] | undefined {
+	if (isModelCacheDisabled()) return undefined;
+	const ttlMs = getModelCacheTtlMs();
+	if (ttlMs <= 0) return undefined;
+	const cache = readCacheFile();
+	if (!cache || cache.keyFingerprint !== keyFingerprint) return undefined;
+	if (now - cache.fetchedAt > ttlMs) return undefined;
+	return cache.models;
+}
+
+// Return cached models regardless of age, as long as the key matches. Used as a
+// resilience fallback when a live discovery request fails.
+export function loadAnyCachedModelCatalog(keyFingerprint: string): CachedModelList | undefined {
+	if (isModelCacheDisabled()) return undefined;
+	const cache = readCacheFile();
+	if (!cache || cache.keyFingerprint !== keyFingerprint) return undefined;
+	return { fetchedAt: cache.fetchedAt, models: cache.models };
+}
+
+export function loadAnyCachedModels(keyFingerprint: string): ModelListItem[] | undefined {
+	return loadAnyCachedModelCatalog(keyFingerprint)?.models;
+}
+
+export function saveModelListCache(keyFingerprint: string, models: ModelListItem[]): boolean {
+	if (isModelCacheDisabled()) return false;
+	try {
+		const path = getCachePath();
+		mkdirSync(dirname(path), { recursive: true });
+		const data: ModelListCacheFile = {
+			version: MODEL_LIST_CACHE_VERSION,
+			fetchedAt: Date.now(),
+			keyFingerprint,
+			models,
+		};
+		writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+		chmodSync(path, 0o600);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export const __testUtils = {
+	getCachePath,
+	DEFAULT_TTL_MS,
+	DISABLE_ENV_VAR,
+	TTL_ENV_VAR,
+};

package/src/cursor-sdk-abort-error-guard.ts

@@ -1,113 +0,0 @@
-import { asRecord } from "./cursor-record-utils.js";
-
-interface CursorSdkAbortErrorSuppressionToken {
-	suppress: boolean;
-}
-
-export interface CursorSdkAbortErrorSuppression {
-	suppressAbortErrors(): void;
-	dispose(): void;
-}
-
-function getString(record: Record<string, unknown> | undefined, key: string): string | undefined {
-	const value = record?.[key];
-	return typeof value === "string" ? value : undefined;
-}
-
-type GenericProcessEmit = (event: string | symbol, ...args: unknown[]) => boolean;
-
-// The local Cursor SDK can surface abort-time ConnectRPC cancellation as a process-level
-// uncaught exception/unhandled rejection even when run.cancel() is awaited/caught.
-const activeSuppressions = new Set<CursorSdkAbortErrorSuppressionToken>();
-let originalProcessEmit: GenericProcessEmit | undefined;
-let captureCallbackInstalled = false;
-
-export function isCursorSdkAbortConnectError(error: unknown): boolean {
-	const record = asRecord(error);
-	const name = error instanceof Error ? error.name : getString(record, "name");
-	const message = error instanceof Error ? error.message : getString(record, "message");
-	const rawMessage = getString(record, "rawMessage") ?? message;
-	const code = record?.code;
-	const cause = asRecord(record?.cause);
-	const causeName = getString(cause, "name");
-	const stack = error instanceof Error ? error.stack ?? "" : getString(record, "stack") ?? "";
-
-	return (
-		name === "ConnectError" &&
-		(code === 1 || code === "canceled") &&
-		Boolean(rawMessage && /(?:operation was aborted|canceled)/i.test(rawMessage)) &&
-		(causeName === "AbortError" || /AbortError/.test(stack)) &&
-		stack.includes("@cursor/sdk") &&
-		stack.includes("@connectrpc/connect-node")
-	);
-}
-
-function hasActiveSuppression(): boolean {
-	for (const suppression of activeSuppressions) {
-		if (suppression.suppress) return true;
-	}
-	return false;
-}
-
-function shouldSuppressProcessError(event: string | symbol, args: readonly unknown[]): boolean {
-	if (event !== "uncaughtException" && event !== "unhandledRejection") return false;
-	return hasActiveSuppression() && isCursorSdkAbortConnectError(args[0]);
-}
-
-function installProcessEmitPatch(): void {
-	if (originalProcessEmit) return;
-	originalProcessEmit = process.emit.bind(process) as GenericProcessEmit;
-	process.emit = function patchedCursorSdkAbortEmit(this: NodeJS.Process, event: string | symbol, ...args: unknown[]): boolean {
-		if (shouldSuppressProcessError(event, args)) return false;
-		return originalProcessEmit!(event, ...args);
-	} as typeof process.emit;
-}
-
-function installCaptureCallbackIfAvailable(): void {
-	if (captureCallbackInstalled || process.hasUncaughtExceptionCaptureCallback()) return;
-	process.setUncaughtExceptionCaptureCallback((error: Error) => {
-		if (shouldSuppressProcessError("uncaughtException", [error])) return;
-		uninstallCaptureCallbackIfIdle(true);
-		if (originalProcessEmit?.("uncaughtException", error)) return;
-		throw error;
-	});
-	captureCallbackInstalled = true;
-}
-
-function uninstallCaptureCallbackIfIdle(force = false): void {
-	if (!captureCallbackInstalled) return;
-	if (!force && activeSuppressions.size > 0) return;
-	process.setUncaughtExceptionCaptureCallback(null);
-	captureCallbackInstalled = false;
-}
-
-function uninstallProcessEmitPatchIfIdle(): void {
-	if (activeSuppressions.size > 0 || !originalProcessEmit) return;
-	uninstallCaptureCallbackIfIdle();
-	process.emit = originalProcessEmit as typeof process.emit;
-	originalProcessEmit = undefined;
-}
-
-export const __testUtils = {
-	activeSuppressionCount: (): number => activeSuppressions.size,
-};
-
-export function installCursorSdkAbortErrorSuppression(): CursorSdkAbortErrorSuppression {
-	installProcessEmitPatch();
-	const token: CursorSdkAbortErrorSuppressionToken = { suppress: false };
-	activeSuppressions.add(token);
-	let disposed = false;
-	return {
-		suppressAbortErrors(): void {
-			if (disposed) return;
-			token.suppress = true;
-			installCaptureCallbackIfAvailable();
-		},
-		dispose(): void {
-			if (disposed) return;
-			disposed = true;
-			activeSuppressions.delete(token);
-			uninstallProcessEmitPatchIfIdle();
-		},
-	};
-}