pi-cursor-sdk 0.1.19 → 0.1.20

package/src/cursor-incomplete-tool-visibility.ts

@@ -1,34 +1,58 @@
-import {
-	CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
-	getCursorReplayDisplayLabel,
-	type CursorReplayLegacyToolName,
-} from "./cursor-tool-names.js";
+import { CURSOR_REPLAY_ACTIVITY_TOOL_NAME } from "./cursor-tool-names.js";
 import { truncateCursorDisplayLine } from "./cursor-display-text.js";
 import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 import {
 	DISCARDED_INCOMPLETE_TOOL_CALL_REASON,
 	type DiscardedIncompleteStartedToolCallReason,
 } from "./cursor-sdk-event-debug.js";
-import { getToolArgs, getToolName, normalizeToolName, truncateArg, type CursorPiToolDisplay } from "./cursor-transcript-utils.js";
-import { resolveTranscriptToolName } from "./cursor-web-tool-activity.js";
+import { truncateArg, type CursorPiToolDisplay } from "./cursor-transcript-utils.js";
+import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
 
 export type IncompleteCursorToolDiscardReason = DiscardedIncompleteStartedToolCallReason;
 
-const INCOMPLETE_TITLE_KEYS: Partial<Record<string, CursorReplayLegacyToolName>> = {
-	task: "cursor_task",
-	mcp: "cursor_mcp",
-	generateimage: "cursor_generate_image",
-	recordscreen: "cursor_record_screen",
-	semsearch: "cursor_sem_search",
-	websearch: "cursor_web_search",
-	webfetch: "cursor_web_fetch",
-	createplan: "cursor_create_plan",
-	updatetodos: "cursor_update_todos",
-	readlints: "cursor_read_lints",
-	delete: "cursor_delete",
-	edit: "cursor_edit",
-	write: "cursor_write",
-};
+export interface IncompleteCursorToolRunOutcome {
+	reason: IncompleteCursorToolDiscardReason;
+	assistantTextProduced: boolean;
+}
+
+export interface IncompleteCursorToolRunOutcomeInput {
+	reason?: IncompleteCursorToolDiscardReason;
+	status?: string;
+	signalAborted?: boolean;
+	assistantTextProduced?: boolean;
+}
+
+export type IncompleteCursorToolVisibilityDecision = "emit" | "suppress" | "debugOnly";
+
+export function buildIncompleteCursorToolRunOutcome(
+	outcome: IncompleteCursorToolRunOutcomeInput = {},
+): IncompleteCursorToolRunOutcome {
+	return {
+		reason:
+			outcome.reason ??
+			(outcome.status === "cancelled" || outcome.signalAborted
+				? "abort"
+				: outcome.status === "error"
+					? "sdk-failure"
+					: DISCARDED_INCOMPLETE_TOOL_CALL_REASON),
+		assistantTextProduced: outcome.assistantTextProduced ?? false,
+	};
+}
+
+export function resolveIncompleteCursorToolVisibility(
+	toolCall: unknown,
+	outcome: IncompleteCursorToolRunOutcome,
+): IncompleteCursorToolVisibilityDecision {
+	const visibility = classifyCursorToolVisibility(toolCall);
+	if (
+		outcome.reason === DISCARDED_INCOMPLETE_TOOL_CALL_REASON &&
+		outcome.assistantTextProduced &&
+		visibility.fastLocalDiscovery
+	) {
+		return "debugOnly";
+	}
+	return "emit";
+}
 
 function buildGenericIncompleteActivityTitle(displayName: string): string {
 	if (!displayName || displayName === "unknown") return "Cursor tool";
@@ -49,25 +73,8 @@ export function formatIncompleteCursorToolReasonText(reason: IncompleteCursorToo
 }
 
 export function getIncompleteCursorToolActivityTitle(toolCall: unknown): string {
-	const args = getToolArgs(toolCall);
-	const name = resolveTranscriptToolName(getToolName(toolCall), args);
-	const normalized = normalizeToolName(name).toLowerCase();
-	const labelKey = INCOMPLETE_TITLE_KEYS[normalized];
-	if (labelKey) return getCursorReplayDisplayLabel(labelKey);
-	switch (normalized) {
-		case "read":
-			return "Cursor read";
-		case "shell":
-			return "Cursor shell";
-		case "grep":
-			return "Cursor grep";
-		case "glob":
-			return "Cursor find";
-		case "ls":
-			return "Cursor ls";
-		default:
-			return buildGenericIncompleteActivityTitle(name);
-	}
+	const visibility = classifyCursorToolVisibility(toolCall);
+	return visibility.incompleteTitle ?? buildGenericIncompleteActivityTitle(visibility.displayName);
 }
 
 export function buildIncompleteCursorToolDisplay(
@@ -75,8 +82,7 @@ export function buildIncompleteCursorToolDisplay(
 	reason: IncompleteCursorToolDiscardReason,
 	options: { apiKey?: string } = {},
 ): CursorPiToolDisplay {
-	const args = getToolArgs(toolCall);
-	const transcriptName = resolveTranscriptToolName(getToolName(toolCall), args);
+	const visibility = classifyCursorToolVisibility(toolCall);
 	const activityTitle = getIncompleteCursorToolActivityTitle(toolCall);
 	const headline = `${activityTitle} did not complete`;
 	const reasonText = scrubSensitiveText(formatIncompleteCursorToolReasonText(reason), options.apiKey);
@@ -84,7 +90,7 @@ export function buildIncompleteCursorToolDisplay(
 	return {
 		toolName: CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
 		args: {
-			cursorToolName: normalizeToolName(transcriptName),
+			cursorToolName: visibility.normalizedName,
 			activityTitle,
 			activitySummary: reasonText,
 			incomplete: true,
@@ -92,7 +98,7 @@ export function buildIncompleteCursorToolDisplay(
 		result: {
 			content: [{ type: "text", text: contentText }],
 			details: {
-				cursorToolName: normalizeToolName(transcriptName),
+				cursorToolName: visibility.normalizedName,
 				title: headline,
 				summary: reasonText,
 			},

package/src/cursor-mcp-timeout-override.ts

@@ -1,17 +1,23 @@
 const CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS = 60_000;
 const DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS = 3_600_000;
+const DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS = 10_000;
+const MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS = 1_000;
 const MAX_NODE_TIMER_DELAY_MS = 2_147_483_647;
 const CURSOR_MCP_TOOL_TIMEOUT_MS_ENV = "PI_CURSOR_MCP_TOOL_TIMEOUT_MS";
 const CURSOR_MCP_TOOL_TIMEOUT_SECONDS_ENV = "PI_CURSOR_MCP_TOOL_TIMEOUT_SECONDS";
+const CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV = "PI_CURSOR_MCP_CONNECT_TIMEOUT_MS";
+const CURSOR_MCP_CONNECT_TIMEOUT_SECONDS_ENV = "PI_CURSOR_MCP_CONNECT_TIMEOUT_SECONDS";
 
 interface CursorMcpToolTimeoutOverrideOptions {
 	timeoutMs?: number;
+	connectTimeoutMs?: number;
 	env?: Record<string, string | undefined>;
 }
 
 interface CursorMcpToolTimeoutOverrideState {
 	installed: boolean;
 	timeoutMs: number;
+	connectTimeoutMs: number;
 	sdkDefaultTimeoutMs: number;
 }
 
@@ -20,7 +26,8 @@ type SetTimeoutHandler = Parameters<GlobalSetTimeout>[0];
 type SetTimeoutDelay = Parameters<GlobalSetTimeout>[1];
 
 let originalSetTimeout: GlobalSetTimeout | undefined;
-let installedTimeoutMs = DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+let installedToolTimeoutMs = DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+let installedConnectTimeoutMs = DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
 
 function parsePositiveNumber(value: string | undefined): number | undefined {
 	const trimmed = value?.trim();
@@ -46,15 +53,47 @@ export function resolveCursorMcpToolTimeoutMs(
 	return DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
 }
 
-export function isCursorSdkMcpToolTimeoutStack(stack: string | undefined): boolean {
+function normalizeConnectTimeoutMs(timeoutMs: number): number {
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
+	return Math.min(
+		Math.max(Math.trunc(timeoutMs), MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS),
+		CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS,
+	);
+}
+
+export function resolveCursorMcpConnectTimeoutMs(
+	env: Record<string, string | undefined> = process.env,
+): number {
+	const explicitMs = parsePositiveNumber(env[CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV]);
+	if (explicitMs !== undefined) return normalizeConnectTimeoutMs(explicitMs);
+
+	const explicitSeconds = parsePositiveNumber(env[CURSOR_MCP_CONNECT_TIMEOUT_SECONDS_ENV]);
+	if (explicitSeconds !== undefined) return normalizeConnectTimeoutMs(explicitSeconds * 1000);
+
+	return DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
+}
+
+function isCursorSdkMcpProtocolTimeoutStack(stack: string | undefined): boolean {
 	if (!stack) return false;
 	return (
 		/(?:node_modules[/\\]@cursor[/\\]sdk|node_modules\/\@cursor\/sdk|@cursor\/sdk\/dist)/.test(stack) &&
-		/\b_setupTimeout\b|\bProtocol\._setupTimeout\b/.test(stack) &&
+		/\b_setupTimeout\b|\bProtocol\._setupTimeout\b/.test(stack)
+	);
+}
+
+export function isCursorSdkMcpToolTimeoutStack(stack: string | undefined): boolean {
+	if (!stack) return false;
+	return (
+		isCursorSdkMcpProtocolTimeoutStack(stack) &&
 		/\bcallTool\b|\bClient\.callTool\b|\bMcpSdkClient\.callTool\b/.test(stack)
 	);
 }
 
+export function isCursorSdkMcpConnectTimeoutStack(stack: string | undefined): boolean {
+	if (!stack || !isCursorSdkMcpProtocolTimeoutStack(stack)) return false;
+	return /\bClient\.(?:connect|listTools)\b|\bMcpSdkClient\.getTools\b/.test(stack);
+}
+
 function isCursorSdkDefaultMcpTimeout(delay: SetTimeoutDelay): boolean {
 	return typeof delay === "number" && delay === CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS;
 }
@@ -67,10 +106,15 @@ function patchedSetTimeout(
 	const delegate = originalSetTimeout;
 	if (!delegate) throw new Error("Cursor MCP timeout override installed without original setTimeout");
 
-	const nextDelay =
-		isCursorSdkDefaultMcpTimeout(delay) && isCursorSdkMcpToolTimeoutStack(new Error().stack)
-			? installedTimeoutMs
-			: delay;
+	let nextDelay = delay;
+	if (isCursorSdkDefaultMcpTimeout(delay)) {
+		const stack = new Error().stack;
+		if (isCursorSdkMcpToolTimeoutStack(stack)) {
+			nextDelay = installedToolTimeoutMs;
+		} else if (isCursorSdkMcpConnectTimeoutStack(stack)) {
+			nextDelay = installedConnectTimeoutMs;
+		}
+	}
 
 	return Reflect.apply(delegate, globalThis, [handler, nextDelay, ...args]) as ReturnType<GlobalSetTimeout>;
 }
@@ -78,9 +122,12 @@ function patchedSetTimeout(
 export function installCursorMcpToolTimeoutOverride(
 	options: CursorMcpToolTimeoutOverrideOptions = {},
 ): CursorMcpToolTimeoutOverrideState {
-	installedTimeoutMs = normalizeOverrideTimeoutMs(
+	installedToolTimeoutMs = normalizeOverrideTimeoutMs(
 		options.timeoutMs ?? resolveCursorMcpToolTimeoutMs(options.env),
 	);
+	installedConnectTimeoutMs = normalizeConnectTimeoutMs(
+		options.connectTimeoutMs ?? resolveCursorMcpConnectTimeoutMs(options.env),
+	);
 
 	if (!originalSetTimeout) {
 		originalSetTimeout = globalThis.setTimeout;
@@ -89,23 +136,31 @@ export function installCursorMcpToolTimeoutOverride(
 
 	return {
 		installed: true,
-		timeoutMs: installedTimeoutMs,
+		timeoutMs: installedToolTimeoutMs,
+		connectTimeoutMs: installedConnectTimeoutMs,
 		sdkDefaultTimeoutMs: CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS,
 	};
 }
 
-export function restoreCursorMcpToolTimeoutOverrideForTests(): void {
+export function restoreCursorMcpToolTimeoutOverride(): void {
 	if (originalSetTimeout) {
 		globalThis.setTimeout = originalSetTimeout;
 		originalSetTimeout = undefined;
 	}
-	installedTimeoutMs = DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+	installedToolTimeoutMs = DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+	installedConnectTimeoutMs = DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
 }
 
+export const restoreCursorMcpToolTimeoutOverrideForTests = restoreCursorMcpToolTimeoutOverride;
+
 export const cursorMcpToolTimeoutOverrideDefaults = {
 	cursorSdkDefaultTimeoutMs: CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS,
 	defaultOverrideTimeoutMs: DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS,
+	defaultConnectTimeoutMs: DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS,
+	minConnectTimeoutMs: MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS,
 	maxNodeTimerDelayMs: MAX_NODE_TIMER_DELAY_MS,
 	timeoutMsEnv: CURSOR_MCP_TOOL_TIMEOUT_MS_ENV,
 	timeoutSecondsEnv: CURSOR_MCP_TOOL_TIMEOUT_SECONDS_ENV,
+	connectTimeoutMsEnv: CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV,
+	connectTimeoutSecondsEnv: CURSOR_MCP_CONNECT_TIMEOUT_SECONDS_ENV,
 } as const;

package/src/cursor-native-tool-display-replay.ts

@@ -35,6 +35,7 @@ export interface CursorReplayToolDetails {
 	diff?: string;
 	firstChangedLine?: number;
 	expandedText?: string;
+	collapseDetailsByDefault?: boolean;
 }
 
 export function asCursorReplayToolDetails(value: unknown): CursorReplayToolDetails | undefined {
@@ -406,7 +407,7 @@ function renderExpandableCursorReplayResult(
 	const summary = details?.summary ?? text.split("\n").find((line) => line.trim()) ?? "completed";
 	let rendered = `${theme.fg("toolTitle", theme.bold(title))} ${theme.fg(isError ? "error" : "success", summary)}`;
 	const expandedText = details?.expandedText ?? (text.includes("\n") ? text : undefined);
-	if (expandedText) {
+	if (expandedText && (options.expanded || !details?.collapseDetailsByDefault)) {
 		const preview = options.expanded ? formatMutedBlock(expandedText, theme) : formatCursorReplayPreview(expandedText, theme);
 		if (preview) rendered += `\n${preview}`;
 	}

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

@@ -16,15 +16,19 @@ import {
 } from "./cursor-sdk-event-debug.js";
 import {
 	buildIncompleteCursorToolDisplay,
+	buildIncompleteCursorToolRunOutcome,
 	formatIncompleteCursorToolTrace,
+	resolveIncompleteCursorToolVisibility,
+	type IncompleteCursorToolRunOutcome,
 	type IncompleteCursorToolDiscardReason,
 } from "./cursor-incomplete-tool-visibility.js";
-import { getToolName, normalizeToolName } from "./cursor-transcript-utils.js";
+import { getToolName } from "./cursor-transcript-utils.js";
 import {
 	CURSOR_TOOL_LIFECYCLE_DEFER_MS,
 	formatCursorToolLifecycleProgressText,
 	isCursorToolLifecycleEligible,
 } from "./cursor-tool-lifecycle.js";
+import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
 
 function formatCursorToolName(toolCall: unknown): string {
 	return truncateCursorDisplayLine(getToolName(toolCall), 80) || "unknown";
@@ -40,9 +44,12 @@ interface CursorShellOutputDeltas {
 	stderr: string[];
 }
 
+function getNormalizedCursorToolName(toolCall: unknown): string {
+	return classifyCursorToolVisibility(toolCall).normalizedName;
+}
+
 function isCursorShellToolCall(toolCall: unknown): boolean {
-	const normalizedName = getToolName(toolCall).replace(/\s+/g, " ").trim().toLowerCase();
-	return normalizedName === "shell" || normalizedName === "run_terminal_cmd" || normalizedName === "terminal" || normalizedName === "bash";
+	return classifyCursorToolVisibility(toolCall).normalizedKey === "shell";
 }
 
 function getCursorShellOutputDelta(update: InteractionUpdate): CursorShellOutputDelta | undefined {
@@ -162,16 +169,30 @@ export class CursorSdkTurnCoordinator {
 	}
 
 	discardIncompleteStartedToolCalls(
-		reason: IncompleteCursorToolDiscardReason = DISCARDED_INCOMPLETE_TOOL_CALL_REASON,
+		outcome: IncompleteCursorToolRunOutcome = buildIncompleteCursorToolRunOutcome(),
 	): void {
 		for (const [callId, toolCall] of this.startedToolCalls) {
 			if (typeof callId !== "string") continue;
+			const toolName = getNormalizedCursorToolName(toolCall);
 			recordDiscardedIncompleteStartedToolCall(this.debugRecorder, process.env, {
-				toolName: normalizeToolName(getToolName(toolCall)),
+				toolName,
 				callId,
-				reason,
+				reason: outcome.reason,
 			});
-			this.emitIncompleteStartedToolCall(toolCall, reason);
+			const visibilityDecision = resolveIncompleteCursorToolVisibility(toolCall, outcome);
+			if (visibilityDecision !== "emit") {
+				this.recordDisplayDecision({
+					action: "skip-incomplete-fast-local",
+					toolName,
+					source: "started",
+					reason:
+						visibilityDecision === "debugOnly" && outcome.assistantTextProduced
+							? "successful-run-text-produced"
+							: visibilityDecision,
+				});
+				continue;
+			}
+			this.emitIncompleteStartedToolCall(toolCall, outcome.reason);
 		}
 		this.startedToolCalls.clear();
 		this.bridgeStartedToolCallIds.clear();
@@ -549,7 +570,7 @@ export class CursorSdkTurnCoordinator {
 		this.emittedLifecycleCallIds.add(callId);
 		this.debugRecorder?.recordCoordinatorEvent("tool_lifecycle", {
 			callId,
-			toolName: normalizeToolName(getToolName(toolCall)),
+			toolName: getNormalizedCursorToolName(toolCall),
 			progressText,
 			liveRun: this.liveRun !== undefined,
 		});

package/src/cursor-provider.ts

@@ -14,7 +14,6 @@ import { installCursorSdkOutputFilter, suppressCursorSdkOutput } from "./cursor-
 import {
 	acquireSessionCursorAgent,
 	buildCursorSessionSendPrompt,
-	commitSessionAgentSend,
 	disposeAllSessionCursorAgents,
 	planCursorSessionSend,
 	resetSessionCursorAgent,
@@ -53,7 +52,6 @@ import { getCheckpointContextWindow, saveCachedContextWindow } from "./context-w
 import {
 	attachCursorSdkEventDebugPiStreamTap,
 	CursorSdkEventDebugSink,
-	DISCARDED_INCOMPLETE_TOOL_CALL_REASON,
 } from "./cursor-sdk-event-debug.js";
 import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
 import { isCursorNativeToolDisplayRuntimeEnabled } from "./cursor-native-tool-display.js";
@@ -71,6 +69,10 @@ import {
 	loadCursorTranscriptWebToolCallsAfterOffset,
 } from "./cursor-agent-message-web-tools.js";
 import { installCursorSdkAbortErrorSuppression } from "./cursor-sdk-abort-error-guard.js";
+import {
+	buildIncompleteCursorToolRunOutcome,
+	type IncompleteCursorToolRunOutcomeInput,
+} from "./cursor-incomplete-tool-visibility.js";
 
 function makeInitialMessage(model: Model<Api>): AssistantMessage {
 	return {
@@ -112,6 +114,21 @@ async function cacheSdkContextWindow(agentId: string, modelId: string): Promise<
 	}
 }
 
+function hasCursorAssistantText(resultText: unknown, textDeltas: readonly string[], fallbackText?: string): boolean {
+	return (
+		hasUsableText(typeof resultText === "string" ? resultText : undefined) ||
+		hasUsableText(textDeltas.join("")) ||
+		hasUsableText(fallbackText)
+	);
+}
+
+function discardIncompleteToolsForRunOutcome(
+	turnCoordinator: CursorSdkTurnCoordinator | undefined,
+	outcome: IncompleteCursorToolRunOutcomeInput,
+): void {
+	turnCoordinator?.discardIncompleteStartedToolCalls(buildIncompleteCursorToolRunOutcome(outcome));
+}
+
 export function streamCursor(
 	model: Model<Api>,
 	context: Context,
@@ -364,6 +381,7 @@ export function streamCursor(
 				throw new CursorLiveRunAbortError();
 			}
 			const activeRun = run;
+			const activeSessionAgentLease = sessionAgentLease;
 
 			if (liveRun) {
 				deferSdkEventDebugFinalize = true;
@@ -371,26 +389,26 @@ export function streamCursor(
 					.wait()
 					.then(async (result) => {
 						sdkEventDebug?.recordWaitResult(result);
-						if (result.status === "finished" && !options?.signal?.aborted) {
+						const finishedSuccessfully = result.status === "finished" && !options?.signal?.aborted;
+						if (finishedSuccessfully) {
 							await replayCursorTranscriptWebToolCalls(activeRun.agentId, cwd, cursorAgentMessageOffset, turnCoordinator);
 						}
-						turnCoordinator.discardIncompleteStartedToolCalls(
-							result.status === "cancelled" || options?.signal?.aborted
-								? "abort"
-								: result.status === "error"
-									? "sdk-failure"
-									: DISCARDED_INCOMPLETE_TOOL_CALL_REASON,
-						);
+						const finalCursorText = finishedSuccessfully
+							? selectCursorFinalText(result.result, liveRun.textDeltas, liveRun.emittedText, turnCoordinator.planTextCandidate)
+							: "";
+						discardIncompleteToolsForRunOutcome(turnCoordinator, {
+							status: result.status,
+							signalAborted: options?.signal?.aborted,
+							assistantTextProduced:
+								finishedSuccessfully && hasCursorAssistantText(result.result, liveRun.textDeltas, turnCoordinator.planTextCandidate),
+						});
 						await sdkEventDebug?.captureRunArtifacts(run);
 						if (liveRun.disposed) return;
 						await cacheSdkContextWindow(liveRun.agent.agentId, model.id);
 						if (liveRun.disposed) return;
-						if (result.status === "finished" && !options?.signal?.aborted) {
-							commitSessionAgentSend(sessionAgentScopeKey, context, bootstrap);
-							cursorLiveRuns.markFinished(
-								liveRun,
-								selectCursorFinalText(result.result, liveRun.textDeltas, liveRun.emittedText, turnCoordinator.planTextCandidate),
-							);
+						if (finishedSuccessfully) {
+							activeSessionAgentLease.commitSend(context, bootstrap);
+							cursorLiveRuns.markFinished(liveRun, finalCursorText);
 						} else if (result.status === "cancelled" || options?.signal?.aborted) {
 							cursorLiveRuns.markCancelled(
 								liveRun,
@@ -412,7 +430,7 @@ export function streamCursor(
 					.catch(async (error: unknown) => {
 						sdkEventDebug?.recordWaitResult({ status: "error", error: String(error) });
 						sdkEventDebug?.recordError("run_wait", error);
-						turnCoordinatorForCleanup?.discardIncompleteStartedToolCalls("sdk-failure");
+						discardIncompleteToolsForRunOutcome(turnCoordinatorForCleanup, { status: "error" });
 						await sdkEventDebug?.captureRunArtifacts(run);
 						if (liveRun.disposed) return;
 						cursorLiveRuns.markError(liveRun, sanitizeCursorProviderError(error, resolvedApiKey ?? options?.apiKey));
@@ -432,7 +450,7 @@ export function streamCursor(
 				} catch (error) {
 					if (error instanceof CursorLiveRunAbortError) {
 						sdkAbortErrorSuppression.suppressAbortErrors();
-						turnCoordinator.discardIncompleteStartedToolCalls("abort");
+						discardIncompleteToolsForRunOutcome(turnCoordinator, { status: "cancelled", signalAborted: true });
 						turnCoordinator.closeTraceBlock();
 						flushPendingCursorLiveRunTraceEventsToStream(stream, partial, liveRun, {
 							includeTracesBehindQueuedTools: true,
@@ -442,6 +460,7 @@ export function streamCursor(
 					throw error;
 				} finally {
 					sdkEventDebugRef.current = undefined;
+					activeSessionAgentLease.trackRunCompletion(waitCompletion);
 					void waitCompletion
 						.finally(async () => {
 							try {
@@ -459,16 +478,21 @@ export function streamCursor(
 
 			const result = await run.wait();
 			sdkEventDebug?.recordWaitResult(result);
-			if (result.status === "finished" && !options?.signal?.aborted) {
+			const finishedSuccessfully = result.status === "finished" && !options?.signal?.aborted;
+			if (finishedSuccessfully) {
 				await replayCursorTranscriptWebToolCalls(run.agentId, cwd, cursorAgentMessageOffset, turnCoordinator);
 			}
-			turnCoordinator.discardIncompleteStartedToolCalls(
-				result.status === "cancelled" || options?.signal?.aborted
-					? "abort"
-					: result.status === "error"
-						? "sdk-failure"
-						: DISCARDED_INCOMPLETE_TOOL_CALL_REASON,
-			);
+			const finalCursorText = finishedSuccessfully
+				? selectCursorFinalText(result.result, textDeltas, textDeltas.join(""), turnCoordinator.planTextCandidate, {
+						allowPartialPrefix: true,
+					})
+				: "";
+			discardIncompleteToolsForRunOutcome(turnCoordinator, {
+				status: result.status,
+				signalAborted: options?.signal?.aborted,
+				assistantTextProduced:
+					finishedSuccessfully && hasCursorAssistantText(result.result, textDeltas, turnCoordinator.planTextCandidate),
+			});
 			await sdkEventDebug?.captureRunArtifacts(run);
 			await cacheSdkContextWindow(agent.agentId, model.id);
 
@@ -493,19 +517,17 @@ export function streamCursor(
 				partial.errorMessage = sanitizeCursorProviderError(failureDetail, resolvedApiKey ?? options?.apiKey);
 				stream.push({ type: "error", reason: "error", error: partial });
 			} else {
-				commitSessionAgentSend(sessionAgentScopeKey, context, bootstrap);
-				const finalCursorText = selectCursorFinalText(result.result, textDeltas, textDeltas.join(""), turnCoordinator.planTextCandidate, {
-					allowPartialPrefix: true,
-				});
+				sessionAgentLease.commitSend(context, bootstrap);
 				turnCoordinator.flushText(hasUsableText(finalCursorText) ? [finalCursorText] : []);
 				applyCursorApproximateUsage(partial, model, context, promptInputTokens);
 				stream.push({ type: "done", reason: "stop", message: partial });
 			}
 			} catch (error) {
 				sdkEventDebug?.recordError("provider_stream", error);
-				turnCoordinatorForCleanup?.discardIncompleteStartedToolCalls(
-					error instanceof CursorLiveRunAbortError ? "abort" : "sdk-failure",
-				);
+				discardIncompleteToolsForRunOutcome(turnCoordinatorForCleanup, {
+					status: error instanceof CursorLiveRunAbortError ? "cancelled" : "error",
+					signalAborted: error instanceof CursorLiveRunAbortError,
+				});
 				if (activeLiveRun && !activeLiveRun.disposed) await cursorLiveRuns.release(activeLiveRun);
 				else await abandonSessionCursorAgent(sessionAgentScopeKey);
 				if (error instanceof CursorLiveRunAbortError) {

package/src/cursor-sdk-event-debug.ts

@@ -35,7 +35,12 @@ export {
 	resolveCursorSdkEventDebugBaseDir,
 } from "./cursor-sdk-event-debug-constants.js";
 
-export type CursorSdkDisplayDecisionAction = "skip-duplicate" | "queue_replay" | "emit_trace" | "ignore-bridge";
+export type CursorSdkDisplayDecisionAction =
+	| "skip-duplicate"
+	| "skip-incomplete-fast-local"
+	| "queue_replay"
+	| "emit_trace"
+	| "ignore-bridge";
 
 export interface CursorSdkDisplayDecisionRecord {
 	action: CursorSdkDisplayDecisionAction;