pi-cursor-sdk 0.1.8 → 0.1.10

package/src/cursor-provider.ts

@@ -8,7 +8,7 @@ import {
 	type AssistantMessage,
 } from "@earendil-works/pi-ai";
 import { Agent, createAgentPlatform } from "@cursor/sdk";
-import type { InteractionUpdate, SDKAgent } from "@cursor/sdk";
+import type { InteractionUpdate, SDKAgent, SettingSource } from "@cursor/sdk";
 import { buildCursorPrompt, type CursorPrompt } from "./context.js";
 import { getEffectiveFastForModelId } from "./cursor-state.js";
 import { buildCursorModelSelection } from "./model-discovery.js";
@@ -17,6 +17,7 @@ import { buildCursorPiToolDisplay, formatCursorToolTranscript, mergeCursorToolCa
 import {
 	canRenderCursorToolNatively,
 	isCursorNativeToolDisplayRuntimeEnabled,
+	deleteCursorNativeToolDisplay,
 	recordCursorNativeToolDisplay,
 	type CursorNativeToolDisplayItem,
 } from "./cursor-native-tool-display.js";
@@ -58,7 +59,9 @@ const AUTH_CURSOR_SDK_ERROR_MESSAGE =
 const APPROX_CHARS_PER_TOKEN = 4;
 const IMAGE_TOKEN_ESTIMATE = 1200;
 const CURSOR_ACTIVITY_TRACE_MAX_CHARS = 50000;
+const DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS = 5 * 60 * 1000;
 const CURSOR_NATIVE_REPLAY_TOOL_ID_PATTERN = /^(cursor-replay-\d+-\d+)-tool-\d+$/;
+const CURSOR_SETTING_SOURCES_ENV = "PI_CURSOR_SETTING_SOURCES";
 
 type CursorNativeQueuedEvent =
 	| { type: "thinking-delta"; text: string }
@@ -73,10 +76,13 @@ interface CursorNativeLiveRun {
 	promptInputTokensReported: boolean;
 	pendingEvents: CursorNativeQueuedEvent[];
 	textDeltas: string[];
+	recordedToolDisplayIds: string[];
 	finalText?: string;
 	done: boolean;
 	cancelled: boolean;
+	disposed: boolean;
 	errorMessage?: string;
+	idleDisposeTimer?: ReturnType<typeof setTimeout>;
 	waiters: Set<() => void>;
 }
 
@@ -88,6 +94,7 @@ interface CursorNativeTurnState {
 }
 
 let cursorNativeReplayCounter = 0;
+let cursorNativeReplayIdleDisposeMs = DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
 const pendingCursorNativeRuns = new Map<string, CursorNativeLiveRun>();
 
 function escapeRegExp(value: string): string {
@@ -125,6 +132,18 @@ function resolveCursorApiKey(apiKey?: string): string | undefined {
 	return trimmed;
 }
 
+function resolveCursorSettingSources(): SettingSource[] | undefined {
+	const raw = process.env[CURSOR_SETTING_SOURCES_ENV]?.trim();
+	if (!raw) return undefined;
+	const normalized = raw.toLowerCase();
+	if (["0", "false", "off", "none", "omit", "disabled"].includes(normalized)) return undefined;
+	if (["1", "true", "on", "all"].includes(normalized)) return ["all"];
+	return raw
+		.split(",")
+		.map((entry) => entry.trim())
+		.filter((entry): entry is SettingSource => Boolean(entry));
+}
+
 function sanitizeError(error: unknown, apiKey?: string): string {
 	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
 	if (message === MISSING_API_KEY_MESSAGE) return MISSING_API_KEY_MESSAGE;
@@ -166,6 +185,11 @@ function estimatePromptInputTokens(prompt: CursorPrompt): number {
 	return estimateTextTokens(prompt.text) + prompt.images.length * IMAGE_TOKEN_ESTIMATE;
 }
 
+function getPromptInputTokenBudget(model: Model<Api>): number {
+	const outputReserveTokens = Math.min(model.maxTokens, Math.max(1, Math.floor(model.contextWindow * 0.2)));
+	return Math.max(1, model.contextWindow - outputReserveTokens);
+}
+
 function setApproximateUsage(partial: AssistantMessage, promptInputTokens: number, outputText: string): void {
 	partial.usage.input = promptInputTokens;
 	partial.usage.output = estimateTextTokens(outputText);
@@ -264,6 +288,21 @@ function queueCursorNativeEvent(run: CursorNativeLiveRun, event: CursorNativeQue
 	notifyCursorNativeRun(run);
 }
 
+function clearCursorNativeRunIdleDispose(run: CursorNativeLiveRun): void {
+	if (!run.idleDisposeTimer) return;
+	clearTimeout(run.idleDisposeTimer);
+	run.idleDisposeTimer = undefined;
+}
+
+function scheduleCursorNativeRunIdleDispose(run: CursorNativeLiveRun): void {
+	if (run.disposed) return;
+	clearCursorNativeRunIdleDispose(run);
+	run.idleDisposeTimer = setTimeout(() => {
+		void disposeCursorNativeRun(run);
+	}, cursorNativeReplayIdleDisposeMs);
+	run.idleDisposeTimer.unref?.();
+}
+
 function isCursorNativeRunReady(run: CursorNativeLiveRun): boolean {
 	return run.pendingEvents.length > 0 || run.done || run.cancelled || run.errorMessage !== undefined;
 }
@@ -310,12 +349,13 @@ function closeCursorNativeThinkingBlock(turn: CursorNativeTurnState): void {
 
 function closeCursorNativeTextBlock(turn: CursorNativeTurnState): string {
 	if (turn.textContentIndex < 0) return "";
-	const block = turn.partial.content[turn.textContentIndex];
+	const contentIndex = turn.textContentIndex;
+	const block = turn.partial.content[contentIndex];
 	turn.textContentIndex = -1;
 	if (block.type !== "text") return "";
 	turn.stream.push({
 		type: "text_end",
-		contentIndex: turn.partial.content.indexOf(block),
+		contentIndex,
 		content: block.text,
 		partial: turn.partial,
 	});
@@ -402,15 +442,24 @@ function emitCursorNativeToolUseTurn(
 		stream.push({ type: "toolcall_delta", contentIndex, delta: JSON.stringify(tool.args), partial });
 		const block = partial.content[contentIndex];
 		if (block.type === "toolCall") stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial });
-		recordCursorNativeToolDisplay({ ...tool, terminate: shouldTerminate });
+		if (recordCursorNativeToolDisplay({ ...tool, terminate: shouldTerminate })) {
+			run.recordedToolDisplayIds.push(tool.id);
+		}
 	}
 	setApproximateUsage(partial, takeCursorNativePromptInputTokens(run), outputText);
 	partial.stopReason = "toolUse";
 	stream.push({ type: "done", reason: "toolUse", message: partial });
+	scheduleCursorNativeRunIdleDispose(run);
 }
 
 async function disposeCursorNativeRun(run: CursorNativeLiveRun): Promise<void> {
+	if (run.disposed) return;
+	run.disposed = true;
 	pendingCursorNativeRuns.delete(run.id);
+	clearCursorNativeRunIdleDispose(run);
+	for (const toolDisplayId of run.recordedToolDisplayIds) deleteCursorNativeToolDisplay(toolDisplayId);
+	run.recordedToolDisplayIds = [];
+	run.waiters.clear();
 	try {
 		await run.agent[Symbol.asyncDispose]();
 	} catch {
@@ -484,7 +533,13 @@ async function replayPendingCursorNativeRun(
 	if (!replayId) return false;
 	const run = pendingCursorNativeRuns.get(replayId);
 	if (!run) return false;
-	await emitCursorNativeRunNextTurn(stream, partial, run, signal);
+	clearCursorNativeRunIdleDispose(run);
+	try {
+		await emitCursorNativeRunNextTurn(stream, partial, run, signal);
+	} catch (error) {
+		if (error instanceof CursorAbortError) await disposeCursorNativeRun(run);
+		throw error;
+	}
 	return true;
 }
 
@@ -498,6 +553,7 @@ export function streamCursor(
 	(async () => {
 		const partial = makeInitialMessage(model);
 		let agent: SDKAgent | null = null;
+		let activeNativeRun: CursorNativeLiveRun | undefined;
 		let resolvedApiKey: string | undefined;
 		let abortSignal: AbortSignal | undefined;
 		let abortListener: (() => void) | undefined;
@@ -519,20 +575,25 @@ export function streamCursor(
 			if (!apiKey) throw new Error(MISSING_API_KEY_MESSAGE);
 			resolvedApiKey = apiKey;
 
+			// pi-ai Context/SimpleStreamOptions do not currently expose ExtensionContext.cwd;
+			// provider calls use the process cwd until pi exposes a session cwd to streamSimple.
 			const cwd = process.cwd();
 			const fastEnabled = getEffectiveFastForModelId(model.id);
 			const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
+			const settingSources = resolveCursorSettingSources();
 
 			agent = await Agent.create({
 				apiKey,
 				model: selection,
-				// Do not pass settingSources here. The Cursor SDK currently writes
-				// setting/rule loading INFO logs directly to process output, which corrupts pi's TUI.
-				local: { cwd },
+				local: settingSources ? { cwd, settingSources } : { cwd },
 			});
 			throwIfAborted();
 
-			const prompt = buildCursorPrompt(context);
+			const prompt = buildCursorPrompt(context, {
+				maxInputTokens: getPromptInputTokenBudget(model),
+				charsPerToken: APPROX_CHARS_PER_TOKEN,
+				imageTokenEstimate: IMAGE_TOKEN_ESTIMATE,
+			});
 			const promptInputTokens = estimatePromptInputTokens(prompt);
 			let thinkingContentIndex = -1;
 			let activityTraceChars = 0;
@@ -551,14 +612,21 @@ export function streamCursor(
 						promptInputTokensReported: false,
 						pendingEvents: [],
 						textDeltas,
+						recordedToolDisplayIds: [],
 						done: false,
 						cancelled: false,
+						disposed: false,
 						waiters: new Set(),
 					}
 				: undefined;
-			if (liveRun) pendingCursorNativeRuns.set(liveRun.id, liveRun);
+			if (liveRun) {
+				pendingCursorNativeRuns.set(liveRun.id, liveRun);
+				activeNativeRun = liveRun;
+			}
 			const startedToolCalls = new Map<string, unknown>();
-			const completedToolFingerprints = new Set<string>();
+			const completedToolIdentities = new Set<string>();
+			const completedStartedToolFingerprints = new Set<string>();
+			const completedFallbackToolFingerprints = new Set<string>();
 
 			const appendLiveTextDelta = (text: string): void => {
 				if (textContentIndex < 0) {
@@ -652,14 +720,31 @@ export function streamCursor(
 				}
 			};
 
-			const handleCompletedToolCall = (toolCall: unknown): void => {
+			const handleCompletedToolCall = (
+				toolCall: unknown,
+				options: { identity?: string; source?: "started" | "fallback" } = {},
+			): void => {
 				const transcript = scrubSensitiveText(formatCursorToolTranscript(toolCall, { cwd }), resolvedApiKey);
 				const display = buildCursorPiToolDisplay(toolCall, { cwd });
 				const fingerprint = getToolFingerprint({ toolName: display.toolName, args: display.args, result: display.result });
-				if (completedToolFingerprints.has(fingerprint)) return;
-				completedToolFingerprints.add(fingerprint);
+				if (options.identity && completedToolIdentities.has(options.identity)) return;
+				if (options.source === "started") {
+					if (completedFallbackToolFingerprints.has(fingerprint)) return;
+				} else if (completedStartedToolFingerprints.has(fingerprint) || completedFallbackToolFingerprints.has(fingerprint)) {
+					return;
+				}
+				if (options.identity) completedToolIdentities.add(options.identity);
+				if (options.source === "started") {
+					completedStartedToolFingerprints.add(fingerprint);
+				} else {
+					completedFallbackToolFingerprints.add(fingerprint);
+				}
 
 				if (useNativeToolReplay && canRenderCursorToolNatively(display.toolName) && liveRun) {
+					if (!nativeToolReplayStarted && textDeltas.length > 0) {
+						for (const text of textDeltas) queueCursorNativeEvent(liveRun, { type: "text-delta", text });
+						textDeltas.length = 0;
+					}
 					nativeToolReplayStarted = true;
 					const id = `${nativeReplayId}-tool-${++nativeToolDisplayCounter}`;
 					queueCursorNativeEvent(liveRun, {
@@ -704,7 +789,11 @@ export function streamCursor(
 				} else if (update.type === "tool-call-completed") {
 					const mergedToolCall = mergeCursorToolCalls(startedToolCalls.get(update.callId), update.toolCall);
 					startedToolCalls.delete(update.callId);
-					handleCompletedToolCall(mergedToolCall);
+					const identity = typeof update.callId === "string" ? `cursor-tool:${update.callId}` : undefined;
+					handleCompletedToolCall(mergedToolCall, {
+						identity,
+						source: identity ? "started" : "fallback",
+					});
 				} else if (update.type === "summary") {
 					const summary = `Cursor summary: ${truncateSingleLine(update.summary)}\n`;
 					if (liveRun && nativeToolReplayStarted) {
@@ -723,7 +812,12 @@ export function streamCursor(
 				const step = getObjectField(args.step, "message") ? args.step : undefined;
 				if (getObjectField(args.step, "type") !== "toolCall") return;
 				const toolCall = getObjectField(step, "message");
-				if (toolCall) handleCompletedToolCall(toolCall);
+				const stepId = getObjectField(args.step, "id") ?? getObjectField(toolCall, "id") ?? getObjectField(toolCall, "callId");
+				if (toolCall) {
+					handleCompletedToolCall(toolCall, {
+						identity: typeof stepId === "string" ? `cursor-tool:${stepId}` : undefined,
+					});
+				}
 			};
 
 			// Handle abort signal
@@ -750,21 +844,31 @@ export function streamCursor(
 				void run
 					.wait()
 					.then(async (result) => {
+						if (liveRun.disposed) return;
 						await cacheSdkContextWindow(liveRun.agent.agentId, model.id);
+						if (liveRun.disposed) return;
 						liveRun.cancelled = result.status === "cancelled";
 						liveRun.finalText = hasUsableText(result.result) ? result.result : liveRun.textDeltas.join("");
 						liveRun.done = true;
 						notifyCursorNativeRun(liveRun);
+						scheduleCursorNativeRunIdleDispose(liveRun);
 					})
 					.catch((error: unknown) => {
+						if (liveRun.disposed) return;
 						liveRun.errorMessage = sanitizeError(error, resolvedApiKey ?? options?.apiKey);
 						notifyCursorNativeRun(liveRun);
+						scheduleCursorNativeRunIdleDispose(liveRun);
 					});
 
-				await waitForCursorNativeRunProgress(liveRun, options?.signal);
-				await settleCursorNativeToolBatch(liveRun);
-				closeTraceBlock();
-				await emitCursorNativeRunNextTurn(stream, partial, liveRun, options?.signal);
+				try {
+					await waitForCursorNativeRunProgress(liveRun, options?.signal);
+					await settleCursorNativeToolBatch(liveRun);
+					closeTraceBlock();
+					await emitCursorNativeRunNextTurn(stream, partial, liveRun, options?.signal);
+				} catch (error) {
+					if (error instanceof CursorAbortError) await disposeCursorNativeRun(liveRun);
+					throw error;
+				}
 				agent = null;
 				return;
 			}
@@ -794,6 +898,8 @@ export function streamCursor(
 				stream.push({ type: "error", reason: "error", error: partial });
 			}
 		} finally {
+			if (activeNativeRun?.disposed) agent = null;
+
 			if (abortSignal && abortListener) {
 				abortSignal.removeEventListener("abort", abortListener);
 			}
@@ -813,3 +919,14 @@ export function streamCursor(
 
 	return stream;
 }
+
+export const __testUtils = {
+	DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS,
+	pendingCursorNativeRunCount: () => pendingCursorNativeRuns.size,
+	setCursorNativeReplayIdleDisposeMs: (value: number) => {
+		cursorNativeReplayIdleDisposeMs = value;
+	},
+	resetCursorNativeReplayIdleDisposeMs: () => {
+		cursorNativeReplayIdleDisposeMs = DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+	},
+};

package/src/cursor-state.ts

@@ -105,16 +105,25 @@ function restoreMapValue(map: Map<string, boolean>, key: string, previous: boole
 function persistFastPreference(pi: ExtensionAPI, baseModelId: string, fast: boolean): void {
 	const previousSession = sessionFastPreferences.get(baseModelId);
 	const previousGlobal = globalFastPreferences.get(baseModelId);
+	let savedGlobal = false;
 	sessionFastPreferences.set(baseModelId, fast);
 	globalFastPreferences.set(baseModelId, fast);
 	try {
 		saveGlobalFastPreferences();
+		savedGlobal = true;
+		pi.appendEntry<CursorFastEntryData>(FAST_ENTRY_TYPE, { baseModelId, fast });
 	} catch (error) {
 		restoreMapValue(sessionFastPreferences, baseModelId, previousSession);
 		restoreMapValue(globalFastPreferences, baseModelId, previousGlobal);
+		if (savedGlobal) {
+			try {
+				saveGlobalFastPreferences();
+			} catch {
+				// Preserve the original append failure reported to the user.
+			}
+		}
 		throw error;
 	}
-	pi.appendEntry<CursorFastEntryData>(FAST_ENTRY_TYPE, { baseModelId, fast });
 }
 
 export function getEffectiveFastForModelId(modelId: string): boolean | undefined {

package/src/cursor-tool-transcript.ts

@@ -1,4 +1,4 @@
-import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { closeSync, openSync, readSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 
 const DEFAULT_MAX_TRANSCRIPT_CHARS = 24000;
@@ -6,6 +6,8 @@ const DEFAULT_MAX_TRANSCRIPT_LINES = 800;
 const DEFAULT_MAX_LIST_ITEMS = 200;
 const DEFAULT_READ_TRANSCRIPT_CHARS = 4000;
 const DEFAULT_READ_TRANSCRIPT_LINES = 12;
+const LOCAL_READ_PREVIEW_NOTICE =
+	"[local file preview at transcript time; Cursor read result content was unavailable]";
 
 interface TranscriptOptions {
 	maxChars?: number;
@@ -194,15 +196,18 @@ function isSensitivePreviewPath(filePath: string): boolean {
 function readFilePreview(path: string, options: TranscriptOptions): string | undefined {
 	const cwd = options.cwd ?? process.cwd();
 	const filePath = resolveFilePath(path, cwd);
-	if (!isPathWithinCwd(filePath, cwd) || isSensitivePreviewPath(filePath)) return undefined;
 
 	const maxChars = options.maxChars ?? DEFAULT_READ_TRANSCRIPT_CHARS;
 	const maxBytes = Math.max(8192, maxChars * 4);
 	let fd: number | undefined;
 	try {
-		const stat = statSync(filePath);
+		const realCwd = realpathSync(cwd);
+		const realFilePath = realpathSync(filePath);
+		if (!isPathWithinCwd(realFilePath, realCwd) || isSensitivePreviewPath(filePath) || isSensitivePreviewPath(realFilePath)) return undefined;
+
+		const stat = statSync(realFilePath);
 		if (!stat.isFile()) return undefined;
-		fd = openSync(filePath, "r");
+		fd = openSync(realFilePath, "r");
 		const buffer = Buffer.alloc(Math.min(stat.size, maxBytes));
 		const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
 		const text = buffer.toString("utf8", 0, bytesRead);
@@ -229,7 +234,10 @@ function getReadContent(args: Record<string, unknown>, result: NormalizedResult,
 	};
 	const value = asRecord(result.value);
 	const resultContent = getString(value, "content");
-	return resultContent && resultContent.length > 0 ? resultContent : rawPath ? (readFilePreview(rawPath, readOptions) ?? stringifyUnknown(result.value)) : stringifyUnknown(result.value);
+	if (resultContent && resultContent.length > 0) return resultContent;
+	if (!rawPath) return stringifyUnknown(result.value);
+	const localPreview = readFilePreview(rawPath, readOptions);
+	return localPreview ? `${LOCAL_READ_PREVIEW_NOTICE}\n${localPreview}` : stringifyUnknown(result.value);
 }
 
 function formatRead(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
@@ -281,15 +289,18 @@ function renderTreeNode(node: unknown, depth = 0, lines: string[] = []): string[
 	return lines;
 }
 
-function formatLs(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
-	const path = formatPathArg(args, options) ?? ".";
-	if (result.status === "error") return joinSections(`ls ${path}`, formatError(result.error));
-
+function getLsBody(result: NormalizedResult, options: TranscriptOptions): string {
 	const value = asRecord(result.value);
 	const root = value?.directoryTreeRoot ?? result.value;
 	const treeLines = renderTreeNode(root);
 	const body = treeLines.length > 0 ? treeLines.join("\n") : stringifyUnknown(result.value);
-	return joinSections(`ls ${path}`, limitText(body, options));
+	return limitText(body, options);
+}
+
+function formatLs(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
+	const path = formatPathArg(args, options) ?? ".";
+	if (result.status === "error") return joinSections(`ls ${path}`, formatError(result.error));
+	return joinSections(`ls ${path}`, getLsBody(result, options));
 }
 
 function formatGlob(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
@@ -528,7 +539,38 @@ export function buildCursorPiToolDisplay(toolCall: unknown, options: TranscriptO
 		return {
 			toolName: "ls",
 			args,
-			result: textToolResult(result.status === "error" ? formatError(result.error) : formatLs(args, result, options).split("\n\n").slice(1).join("\n\n").trim()),
+			result: textToolResult(result.status === "error" ? formatError(result.error) : getLsBody(result, options).trim()),
+			isError: result.status === "error",
+		};
+	}
+
+	if (name === "edit") {
+		const value = asRecord(result.value);
+		return {
+			toolName: "cursor_edit",
+			args,
+			result: textToolResult(formatEdit(args, result, options), {
+				cursorToolName: "edit",
+				path: typeof args.path === "string" ? formatDisplayPath(args.path, options.cwd) : undefined,
+				linesAdded: getNumber(value, "linesAdded"),
+				linesRemoved: getNumber(value, "linesRemoved"),
+				diffString: getString(value, "diffString"),
+			}),
+			isError: result.status === "error",
+		};
+	}
+
+	if (name === "write") {
+		const value = asRecord(result.value);
+		return {
+			toolName: "cursor_write",
+			args,
+			result: textToolResult(formatWrite(args, result, options), {
+				cursorToolName: "write",
+				path: typeof args.path === "string" ? formatDisplayPath(args.path, options.cwd) : undefined,
+				linesCreated: getNumber(value, "linesCreated"),
+				fileSize: getNumber(value, "fileSize"),
+			}),
 			isError: result.status === "error",
 		};
 	}

package/src/index.ts

@@ -1,9 +1,24 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ProviderConfig, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { discoverModels, type CursorModelFallbackIssue } from "./model-discovery.js";
 import { registerCursorFastControls } from "./cursor-state.js";
 import { registerCursorNativeToolDisplay } from "./cursor-native-tool-display.js";
 import { streamCursor } from "./cursor-provider.js";
 
+function createCursorProviderConfig(models: ProviderModelConfig[]): ProviderConfig {
+	return {
+		name: "Cursor",
+		baseUrl: "https://cursor.com",
+		apiKey: "CURSOR_API_KEY",
+		api: "cursor-sdk",
+		models,
+		streamSimple: streamCursor,
+	};
+}
+
+function registerCursorProvider(pi: ExtensionAPI, models: ProviderModelConfig[]): void {
+	pi.registerProvider("cursor", createCursorProviderConfig(models));
+}
+
 export default async function (pi: ExtensionAPI) {
 	registerCursorFastControls(pi);
 	registerCursorNativeToolDisplay(pi);
@@ -21,12 +36,24 @@ export default async function (pi: ExtensionAPI) {
 		});
 	}
 
-	pi.registerProvider("cursor", {
-		name: "Cursor",
-		baseUrl: "https://cursor.com",
-		apiKey: "CURSOR_API_KEY",
-		api: "cursor-sdk",
-		models,
-		streamSimple: streamCursor,
+	pi.registerCommand("cursor-refresh-models", {
+		description: "Refresh the live Cursor model catalog without restarting pi",
+		handler: async (_args, ctx) => {
+			let refreshFallbackIssue: CursorModelFallbackIssue | undefined;
+			const refreshedModels = await discoverModels({
+				onFallback: (issue) => {
+					refreshFallbackIssue = issue;
+				},
+			});
+			registerCursorProvider(pi, refreshedModels);
+			if (!ctx.hasUI) return;
+			if (refreshFallbackIssue) {
+				ctx.ui.notify(`Cursor model catalog refresh still using fallback models: ${refreshFallbackIssue.message}`, "warning");
+			} else {
+				ctx.ui.notify(`Cursor model catalog refreshed with ${refreshedModels.length} model${refreshedModels.length === 1 ? "" : "s"}.`, "info");
+			}
+		},
 	});
+
+	registerCursorProvider(pi, models);
 }