pi-cursor-sdk 0.1.27 → 0.1.29

package/src/cursor-provider-turn-lifecycle-emitter.ts

@@ -9,6 +9,7 @@ import {
 	isCursorToolLifecycleEligible,
 } from "./cursor-tool-lifecycle.js";
 import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
+import { getStartedToolCallFingerprint } from "./cursor-provider-turn-tool-ledger.js";
 
 function getNormalizedCursorToolName(toolCall: unknown): string {
 	return classifyCursorToolVisibility(toolCall).normalizedName;
@@ -32,6 +33,10 @@ export class CursorToolLifecycleEmitter {
 	private readonly isBridgeMcpToolCall: (toolCall: unknown) => boolean;
 	private readonly emittedLifecycleCallIds = new Set<string>();
 	private readonly lifecycleTimers = new Map<string, ReturnType<typeof setTimeout>>();
+	private readonly activeLifecycleFingerprintOwners = new Map<string, string>();
+	private readonly lifecycleFingerprintByCallId = new Map<string, string>();
+	private readonly activeLifecycleProgressTextOwners = new Map<string, string>();
+	private readonly lifecycleProgressTextByCallId = new Map<string, string>();
 
 	constructor(options: CursorToolLifecycleEmitterOptions) {
 		this.liveRun = options.liveRun;
@@ -47,12 +52,47 @@ export class CursorToolLifecycleEmitter {
 		if (this.isBridgeMcpToolCall(toolCall)) return;
 		if (!isCursorToolLifecycleEligible(toolCall)) return;
 
+		const progressText = formatCursorToolLifecycleProgressText(toolCall, this.resolvedApiKey);
+		if (!progressText) return;
+
+		const fingerprint = getStartedToolCallFingerprint(toolCall);
+		const existingOwner = this.activeLifecycleFingerprintOwners.get(fingerprint);
+		if (existingOwner && existingOwner !== callId) {
+			this.debugRecorder?.recordCoordinatorEvent("tool_lifecycle_skip", {
+				callId,
+				ownerCallId: existingOwner,
+				toolName: getNormalizedCursorToolName(toolCall),
+				reason: "duplicate-active-fingerprint",
+			});
+			return;
+		}
+
 		this.cancel(callId);
+		this.activeLifecycleFingerprintOwners.set(fingerprint, callId);
+		this.lifecycleFingerprintByCallId.set(callId, fingerprint);
+		if (!this.activeLifecycleProgressTextOwners.has(progressText)) {
+			this.activeLifecycleProgressTextOwners.set(progressText, callId);
+		}
+		this.lifecycleProgressTextByCallId.set(callId, progressText);
 		const timer = setTimeout(() => {
 			this.lifecycleTimers.delete(callId);
-			if (!this.hasStartedToolCall(callId)) return;
+			if (!this.hasStartedToolCall(callId)) {
+				this.clearLifecycleIdentity(callId);
+				return;
+			}
 			if (this.emittedLifecycleCallIds.has(callId)) return;
-			this.emit(callId, toolCall);
+			const progressOwner = this.activeLifecycleProgressTextOwners.get(progressText);
+			if (progressOwner && progressOwner !== callId && this.hasStartedToolCall(progressOwner)) {
+				this.debugRecorder?.recordCoordinatorEvent("tool_lifecycle_skip", {
+					callId,
+					ownerCallId: progressOwner,
+					toolName: getNormalizedCursorToolName(toolCall),
+					reason: "duplicate-active-progress-text",
+				});
+				return;
+			}
+			this.activeLifecycleProgressTextOwners.set(progressText, callId);
+			this.emit(callId, toolCall, progressText);
 		}, CURSOR_TOOL_LIFECYCLE_DEFER_MS);
 		timer.unref?.();
 		this.lifecycleTimers.set(callId, timer);
@@ -60,20 +100,37 @@ export class CursorToolLifecycleEmitter {
 
 	cancel(callId: string): void {
 		const timer = this.lifecycleTimers.get(callId);
-		if (!timer) return;
-		clearTimeout(timer);
-		this.lifecycleTimers.delete(callId);
+		if (timer) {
+			clearTimeout(timer);
+			this.lifecycleTimers.delete(callId);
+		}
+		this.clearLifecycleIdentity(callId);
 	}
 
 	clear(): void {
 		this.emittedLifecycleCallIds.clear();
 		for (const timer of this.lifecycleTimers.values()) clearTimeout(timer);
 		this.lifecycleTimers.clear();
+		this.activeLifecycleFingerprintOwners.clear();
+		this.lifecycleFingerprintByCallId.clear();
+		this.activeLifecycleProgressTextOwners.clear();
+		this.lifecycleProgressTextByCallId.clear();
 	}
 
-	private emit(callId: string, toolCall: unknown): void {
-		const progressText = formatCursorToolLifecycleProgressText(toolCall, this.resolvedApiKey);
-		if (!progressText) return;
+	private clearLifecycleIdentity(callId: string): void {
+		const fingerprint = this.lifecycleFingerprintByCallId.get(callId);
+		if (fingerprint && this.activeLifecycleFingerprintOwners.get(fingerprint) === callId) {
+			this.activeLifecycleFingerprintOwners.delete(fingerprint);
+		}
+		this.lifecycleFingerprintByCallId.delete(callId);
+		const progressText = this.lifecycleProgressTextByCallId.get(callId);
+		if (progressText && this.activeLifecycleProgressTextOwners.get(progressText) === callId) {
+			this.activeLifecycleProgressTextOwners.delete(progressText);
+		}
+		this.lifecycleProgressTextByCallId.delete(callId);
+	}
+
+	private emit(callId: string, toolCall: unknown, progressText: string): void {
 		this.emittedLifecycleCallIds.add(callId);
 		this.debugRecorder?.recordCoordinatorEvent("tool_lifecycle", {
 			callId,

package/src/cursor-provider-turn-tool-ledger.ts

@@ -1,5 +1,4 @@
-import { getField } from "./cursor-record-utils.js";
-import { getToolName } from "./cursor-transcript-utils.js";
+import { getToolArgs, getToolName } from "./cursor-transcript-utils.js";
 
 export type CursorToolDisplaySource = "started" | "fallback" | "transcript";
 
@@ -122,5 +121,5 @@ export function getToolFingerprint(value: unknown): string {
 }
 
 export function getStartedToolCallFingerprint(toolCall: unknown): string {
-	return getToolFingerprint({ toolName: getToolName(toolCall), args: getField(toolCall, "args") });
+	return getToolFingerprint({ toolName: getToolName(toolCall), args: getToolArgs(toolCall) });
 }

package/src/cursor-run-final-text.ts

@@ -1,4 +1,5 @@
-import { hasUsableText } from "./cursor-record-utils.js";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { asRecord, hasUsableText } from "./cursor-record-utils.js";
 
 function isCursorTextBoundary(text: string, index: number): boolean {
 	if (index <= 0 || index >= text.length) return true;
@@ -39,6 +40,15 @@ export function trimCurrentTurnAlreadyEmittedCursorText(
 	return trimAlreadyEmittedCursorText(text, emittedText);
 }
 
+export function getFinalAssistantText(message: Pick<AssistantMessage, "content">): string {
+	for (let index = message.content.length - 1; index >= 0; index--) {
+		const block = asRecord(message.content[index]);
+		if (block?.type !== "text" || typeof block.text !== "string") continue;
+		if (hasUsableText(block.text)) return block.text;
+	}
+	return "";
+}
+
 export function selectCursorFinalText(
 	resultText: unknown,
 	textDeltas: readonly string[],

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

@@ -26,7 +26,7 @@ function hasActiveAbortSuppression(): boolean {
 }
 
 function isCursorProvenance(source: string): boolean {
-	return source === "cursor-sdk-stack" || source === "cursor-backend-details";
+	return source === "cursor-sdk-stack" || source === "cursor-extension-connect-stack" || source === "cursor-backend-details";
 }
 
 function shouldSuppressProcessError(event: string | symbol, args: readonly unknown[]): boolean {

package/src/cursor-state.ts

@@ -29,7 +29,8 @@ export type CursorAgentMode = AgentModeOption;
 const DEFAULT_CURSOR_AGENT_MODE: AgentModeOption = "agent";
 
 interface CursorFastEntryData {
-	baseModelId: string;
+	modelId?: string;
+	baseModelId?: string;
 	fast: boolean;
 }
 
@@ -71,7 +72,11 @@ export function parseCursorAgentMode(raw: unknown): AgentModeOption | undefined
 function isCursorFastEntryData(value: unknown): value is CursorFastEntryData {
 	if (!value || typeof value !== "object") return false;
 	const data = value as Record<string, unknown>;
-	return typeof data.baseModelId === "string" && typeof data.fast === "boolean";
+	return (typeof data.modelId === "string" || typeof data.baseModelId === "string") && typeof data.fast === "boolean";
+}
+
+function getCursorFastEntryModelId(data: CursorFastEntryData): string {
+	return data.modelId ?? data.baseModelId ?? "";
 }
 
 function isCursorModeEntryData(value: unknown): value is CursorModeEntryData {
@@ -113,7 +118,8 @@ function restoreSessionFastPreferences(ctx: { sessionManager: Pick<ExtensionCont
 	for (const entry of ctx.sessionManager.getBranch()) {
 		if (entry.type !== "custom" || entry.customType !== FAST_ENTRY_TYPE) continue;
 		if (isCursorFastEntryData(entry.data)) {
-			sessionFastPreferences.set(entry.data.baseModelId, entry.data.fast);
+			const modelId = getCursorFastEntryModelId(entry.data);
+			if (modelId) sessionFastPreferences.set(modelId, entry.data.fast);
 		}
 	}
 }
@@ -128,12 +134,26 @@ function restoreSessionCursorMode(ctx: { sessionManager: Pick<ExtensionContext["
 	}
 }
 
-function getEffectiveFast(baseModelId: string, modelId: string): boolean | undefined {
+function getFastPreferenceModelId(metadata: NonNullable<ReturnType<typeof getCursorModelMetadata>>): string {
+	return metadata.selectionModelId || metadata.baseModelId;
+}
+
+function getStoredFastPreference(metadata: NonNullable<ReturnType<typeof getCursorModelMetadata>>): boolean | undefined {
+	const preferenceModelId = getFastPreferenceModelId(metadata);
+	return (
+		sessionFastPreferences.get(preferenceModelId) ??
+		(preferenceModelId !== metadata.baseModelId ? sessionFastPreferences.get(metadata.baseModelId) : undefined) ??
+		globalFastPreferences.get(preferenceModelId) ??
+		(preferenceModelId !== metadata.baseModelId ? globalFastPreferences.get(metadata.baseModelId) : undefined)
+	);
+}
+
+function getEffectiveFast(modelId: string): boolean | undefined {
 	const metadata = getCursorModelMetadata(modelId);
 	if (!metadata?.supportsFast) return undefined;
 	if (cliForceNoFast) return false;
 	if (cliForceFast) return true;
-	return sessionFastPreferences.get(baseModelId) ?? globalFastPreferences.get(baseModelId) ?? metadata.defaultFast;
+	return getStoredFastPreference(metadata) ?? metadata.defaultFast;
 }
 
 function formatInvalidCursorMode(raw: string): string {
@@ -168,7 +188,7 @@ function updateCursorStatus(ctx: Pick<ExtensionContext, "model" | "ui">, model =
 		return;
 	}
 	const metadata = getCursorModelMetadata(model.id);
-	const fast = metadata?.supportsFast ? getEffectiveFast(metadata.baseModelId, model.id) : undefined;
+	const fast = metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
 	ctx.ui.setStatus("cursor", formatCursorStatus(fast));
 }
 
@@ -186,19 +206,19 @@ function restoreMapValue(map: Map<string, boolean>, key: string, previous: boole
 	}
 }
 
-function persistFastPreference(pi: Pick<ExtensionAPI, "appendEntry">, baseModelId: string, fast: boolean): void {
-	const previousSession = sessionFastPreferences.get(baseModelId);
-	const previousGlobal = globalFastPreferences.get(baseModelId);
+function persistFastPreference(pi: Pick<ExtensionAPI, "appendEntry">, modelId: string, fast: boolean): void {
+	const previousSession = sessionFastPreferences.get(modelId);
+	const previousGlobal = globalFastPreferences.get(modelId);
 	let savedGlobal = false;
-	sessionFastPreferences.set(baseModelId, fast);
-	globalFastPreferences.set(baseModelId, fast);
+	sessionFastPreferences.set(modelId, fast);
+	globalFastPreferences.set(modelId, fast);
 	try {
 		saveGlobalFastPreferences();
 		savedGlobal = true;
-		pi.appendEntry<CursorFastEntryData>(FAST_ENTRY_TYPE, { baseModelId, fast });
+		pi.appendEntry<CursorFastEntryData>(FAST_ENTRY_TYPE, { modelId, fast });
 	} catch (error) {
-		restoreMapValue(sessionFastPreferences, baseModelId, previousSession);
-		restoreMapValue(globalFastPreferences, baseModelId, previousGlobal);
+		restoreMapValue(sessionFastPreferences, modelId, previousSession);
+		restoreMapValue(globalFastPreferences, modelId, previousGlobal);
 		if (savedGlobal) {
 			try {
 				saveGlobalFastPreferences();
@@ -285,9 +305,7 @@ function emitCursorToolsDebugReport(
 }
 
 export function getEffectiveFastForModelId(modelId: string): boolean | undefined {
-	const metadata = getCursorModelMetadata(modelId);
-	if (!metadata) return undefined;
-	return getEffectiveFast(metadata.baseModelId, modelId);
+	return getEffectiveFast(modelId);
 }
 
 export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtensionApi): void {
@@ -327,10 +345,11 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 				return;
 			}
 
-			const current = getEffectiveFast(metadata.baseModelId, metadata.piModelId) ?? false;
+			const preferenceModelId = getFastPreferenceModelId(metadata);
+			const current = getEffectiveFast(metadata.piModelId) ?? false;
 			const next = !current;
 			try {
-				persistFastPreference(pi, metadata.baseModelId, next);
+				persistFastPreference(pi, preferenceModelId, next);
 			} catch (error) {
 				updateCursorStatus(ctx);
 				ctx.ui.notify(`Failed to save Cursor fast preference: ${error instanceof Error ? error.message : String(error)}`, "error");

package/src/cursor-tool-lifecycle.ts

@@ -45,7 +45,7 @@ export function buildCursorToolLifecycleLabel(toolCall: unknown, apiKey?: string
 			return scrubLifecycleDetail(getString(args, "description"), apiKey) ?? "task";
 		}
 		case "shell": {
-			return "shell";
+			return scrubLifecycleDetail(getString(args, "command") ?? getString(args, "cmd"), apiKey);
 		}
 		case "mcp": {
 			return scrubLifecycleDetail(getString(args, "toolName"), apiKey) ?? "mcp";

package/src/cursor-tool-manifest.ts

@@ -4,7 +4,7 @@ import type { CursorPiToolBridgeSnapshot } from "./cursor-pi-tool-bridge-types.j
 export const CURSOR_TOOL_MANIFEST_ENV = "PI_CURSOR_TOOL_MANIFEST";
 
 /**
- * Representative @cursor/sdk@1.0.16 local-agent ToolType values; actual exposure can vary by run.
+ * Representative @cursor/sdk@1.0.17 local-agent ToolType values; actual exposure can vary by run.
  * See docs/cursor-native-tool-replay.md#sdk-tooltype-replay-matrix.
  */
 export const CURSOR_HOST_TOOL_MANIFEST_SUMMARY =

package/src/cursor-transcript-utils.ts

@@ -145,14 +145,18 @@ export function formatError(error: unknown): string {
 	return text ? `Error: ${text}` : "Error";
 }
 
+function normalizeDisplaySeparators(path: string): string {
+	return path.replace(/\\/g, "/");
+}
+
 export function formatDisplayPath(path: string, cwd = process.cwd()): string {
 	const trimmed = path.trim();
 	if (!trimmed) return trimmed;
-	if (!isAbsolute(trimmed)) return trimmed;
+	if (!isAbsolute(trimmed)) return normalizeDisplaySeparators(trimmed);
 	const relativePath = relative(cwd, trimmed);
 	if (!relativePath || relativePath === "") return ".";
-	if (relativePath.startsWith("..") || isAbsolute(relativePath)) return trimmed;
-	return relativePath;
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) return normalizeDisplaySeparators(trimmed);
+	return normalizeDisplaySeparators(relativePath);
 }
 
 export function formatDiffPath(path: string, cwd = process.cwd()): string {