pi-cursor-sdk 0.4.0 → 0.5.2

package/src/cursor-live-run-coordinator.ts

@@ -11,7 +11,7 @@ import {
 	type CursorLiveToolResultConsumption,
 } from "./cursor-live-run-accounting.js";
 import type { CursorSdkTurnUsage } from "./cursor-usage-accounting.js";
-import type { CursorNativeToolDisplayItem } from "./cursor-native-tool-display-state.js";
+import type { CursorNativeToolDisplayItem, CursorNativeToolDisplayState } from "./cursor-native-tool-display-state.js";
 import type { CursorPiBridgeToolRequest, CursorPiToolBridgeRun } from "./cursor-pi-tool-bridge.js";
 import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
 import type { CursorSdkEventDebugRecorder } from "./cursor-sdk-event-debug.js";
@@ -45,7 +45,7 @@ export interface CursorLiveRun {
 	sdkRun?: CursorLiveSdkRun;
 	ignoreFutureSdkTurnUsage?: boolean;
 	accounting: CursorLiveRunAccountingState;
-	billedTurnUsage?: CursorSdkTurnUsage;
+	onAbandon?: () => Promise<void>;
 	pendingEvents: CursorLiveQueuedEvent[];
 	textDeltas: string[];
 	emittedText: string;
@@ -59,6 +59,7 @@ export interface CursorLiveRun {
 	abortMessage?: string;
 	chainUserInputAfterCompletion: boolean;
 	debugRecorder?: CursorSdkEventDebugRecorder;
+	nativeDisplay?: CursorNativeToolDisplayState;
 }
 
 export interface CursorLiveRunCreateParams {
@@ -70,6 +71,7 @@ export interface CursorLiveRunCreateParams {
 	promptInputTokens: number;
 	textDeltas?: string[];
 	debugRecorder?: CursorSdkEventDebugRecorder;
+	nativeDisplay?: CursorNativeToolDisplayState;
 }
 
 export interface CursorLiveRunCoordinatorDeps {
@@ -96,7 +98,7 @@ export interface CursorLiveRunCoordinator {
 	consumeToolResults(run: CursorLiveRun, context: Context, getReplayId: CursorReplayIdResolver): CursorLiveToolResultConsumption;
 	takeTurnInputTokens(run: CursorLiveRun, toolResultInputTokens: number): number;
 	takeSdkTurnUsage(run: CursorLiveRun): CursorSdkTurnUsage | undefined;
-	getPendingFromContext(context: Context, getReplayId: CursorReplayIdResolver): CursorLiveRun | undefined;
+	getPendingFromContext(context: Context, getReplayId: CursorReplayIdResolver, scopeKey: string): CursorLiveRun | undefined;
 	getActiveForScope(scopeKey?: string): CursorLiveRun | undefined;
 	isReady(run: CursorLiveRun): boolean;
 	waitForProgress(run: CursorLiveRun, signal?: AbortSignal): Promise<void>;
@@ -151,6 +153,7 @@ interface CursorLiveRunPrivateState {
 	waiters: Set<ProgressWaiter>;
 	idleDisposeTimer?: ReturnType<typeof setTimeout>;
 	idleDisposeRequested: boolean;
+	pendingCallUnsubscribers?: Array<() => void>;
 	leased: boolean;
 	leaseQueue: LeaseWaiter[];
 	releasing?: Promise<void>;
@@ -293,6 +296,7 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				bridgeRun: params.bridgeRun,
 				sessionBridgeRun: params.sessionBridgeRun,
 				sessionAgentScopeKey,
+				nativeDisplay: params.nativeDisplay,
 				accounting: createCursorLiveRunAccountingState(params.promptInputTokens),
 				pendingEvents: [],
 				textDeltas: params.textDeltas ?? [],
@@ -310,6 +314,12 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				leased: false,
 				leaseQueue: [],
 			});
+			const state = getPrivateState(run);
+			state.pendingCallUnsubscribers = [...new Set([run.bridgeRun, run.sessionBridgeRun])].flatMap((bridge) =>
+				bridge ? [bridge.onPendingToolCallsChanged(() => {
+					if (state.idleDisposeRequested || state.idleDisposeTimer) coordinator.requestIdleDispose(run);
+				})] : [],
+			);
 			pendingRuns.set(run.id, run);
 			pendingRunIdsByScopeKey.set(sessionAgentScopeKey, run.id);
 			return run;
@@ -420,7 +430,9 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 			return taken.sdkTurnUsage;
 		},
 
-		getPendingFromContext(context, getReplayId): CursorLiveRun | undefined {
+		getPendingFromContext(context, getReplayId, scopeKey): CursorLiveRun | undefined {
+			const run = getUndisposed(pendingRunIdsByScopeKey.get(scopeKey));
+			if (!run) return undefined;
 			const messages = getCursorConversationMessages(context);
 			let index = messages.length - 1;
 			while (index >= 0 && messages[index]?.role === "user") {
@@ -430,15 +442,7 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 			for (; index >= 0; index -= 1) {
 				const message = messages[index];
 				if (message.role !== "toolResult") break;
-				const replayId = getReplayId(message.toolCallId);
-				if (replayId) {
-					const replayRun = getUndisposed(replayId);
-					if (replayRun) return replayRun;
-				}
-				for (const run of pendingRuns.values()) {
-					if (run.disposed) continue;
-					if (run.bridgeRun?.hasPendingPiToolCallId(message.toolCallId)) return run;
-				}
+				if (matchesCursorLiveRunToolResult(run, message, getReplayId)) return run;
 			}
 			return undefined;
 		},
@@ -495,9 +499,15 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 			const state = getPrivateState(run);
 			clearIdleDisposeTimer(run);
 			state.idleDisposeRequested = true;
-			if (state.leased || state.leaseQueue.length > 0) return;
-			state.idleDisposeRequested = false;
+			if (state.leased || state.leaseQueue.length > 0 ||
+				[run.bridgeRun, run.sessionBridgeRun].some((bridge) => bridge?.hasPendingToolCalls())) return;
 			state.idleDisposeTimer = setTimeout(() => {
+				state.idleDisposeTimer = undefined;
+				if (state.leased || state.leaseQueue.length > 0 ||
+					[run.bridgeRun, run.sessionBridgeRun].some((bridge) => bridge?.hasPendingToolCalls())) {
+					coordinator.requestIdleDispose(run);
+					return;
+				}
 				void coordinator.release(run).catch(() => {
 					// Idle dispose must not leave release failures as unhandled rejections.
 				});
@@ -512,6 +522,12 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				if (run.disposed) return;
 				const abandoned = !isSuccessfulCursorLiveRun(run);
 				run.disposed = true;
+				for (const unsubscribe of state.pendingCallUnsubscribers ?? []) {
+					try { unsubscribe(); } catch {
+						// Cleanup continues even if an observer cannot detach.
+					}
+				}
+				state.pendingCallUnsubscribers = [];
 				unregister(run);
 				clearIdleDisposeTimer(run);
 				state.idleDisposeRequested = false;
@@ -531,11 +547,13 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				}
 				if (abandoned) {
 					if (!run.done) {
+						const usageCompletion = run.onAbandon?.();
 						try {
 							await cancelCursorLiveSdkRun(run);
 						} catch {
 							// cancellation failure should not block session-agent abandonment
 						}
+						await usageCompletion;
 					}
 					await deps.abandonSessionAgent(run.sessionAgentScopeKey);
 				}

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

@@ -91,7 +91,9 @@ export function isCursorSdkMcpToolTimeoutStack(stack: string | undefined): boole
 
 export function isCursorSdkMcpConnectTimeoutStack(stack: string | undefined): boolean {
 	if (!stack || !isCursorSdkMcpProtocolTimeoutStack(stack)) return false;
-	return /\bClient\.(?:connect|listTools)\b|\bMcpSdkClient\.getTools\b/.test(stack);
+	// SDK 1.0.36 minifies the Client class name; the protocol method and SDK
+	// frame, not that constructor's spelling, establish this timeout purpose.
+	return /^\s*at (?:[\w$]+\.)?(?:connect|listTools|getTools)\s*\(.*(?:node_modules[/\\]@cursor[/\\]sdk|@cursor\/sdk\/dist)/m.test(stack);
 }
 
 function isCursorSdkDefaultMcpTimeout(delay: SetTimeoutDelay): boolean {

package/src/cursor-native-replay-routing.ts

@@ -8,6 +8,7 @@ export interface NativeReplayRoutingInput {
 	toolName: string;
 	useNativeToolReplay: boolean;
 	activeToolNames?: ReadonlySet<string>;
+	registeredToolNames?: ReadonlySet<string>;
 	hasLiveRun: boolean;
 }
 
@@ -20,7 +21,7 @@ export function isNativeToolActiveInContext(toolName: string, activeToolNames?:
  * Extension resync (pi active tools) is separate; this uses context.tools snapshot only.
  */
 export function resolveNativeReplayDisposition(input: NativeReplayRoutingInput): NativeReplayDisposition {
-	if (!input.useNativeToolReplay || !canRenderCursorToolNatively(input.toolName)) {
+	if (!input.useNativeToolReplay || !(input.registeredToolNames?.has(input.toolName) ?? canRenderCursorToolNatively(input.toolName))) {
 		return "transcript_trace";
 	}
 	if (isNativeToolActiveInContext(input.toolName, input.activeToolNames) && input.hasLiveRun) {

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

@@ -13,9 +13,9 @@ import {
 	isCursorNativeToolRegistrationRequested,
 	NATIVE_CURSOR_TOOL_DISPLAY_ENV,
 	readBooleanEnv,
-	registeredNativeToolNames,
+	getCursorNativeToolDisplayState,
+	registerCursorNativeToolDisplayState,
 	setCursorNativeToolDisplayRuntimeRequested,
-	skippedNativeToolNames,
 } from "./cursor-native-tool-display-state.js";
 import { isCursorReplayToolName } from "./cursor-tool-presentation-registry.js";
 import { registerNativeCursorTool } from "./cursor-native-tool-display-tools.js";
@@ -30,7 +30,11 @@ function isCursorCorePiReplayToolName(toolName: string): toolName is (typeof CUR
 type CursorNativeToolActivationApi = Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">;
 type CursorNativeToolRegistryApi = CursorNativeToolActivationApi & Pick<ExtensionAPI, "getAllTools" | "registerTool">;
 
-export interface CursorNativeToolDisplayExtensionApi extends CursorNativeToolRegistryApi, CursorModelLifecycleExtensionApi {}
+export type CursorNativeToolDisplayExtensionApi = CursorNativeToolRegistryApi
+	& CursorModelLifecycleExtensionApi & Parameters<typeof registerCursorNativeToolDisplayState>[0];
+
+// Pi filters getAllTools even after registration; new/reloaded extensions receive a new API.
+const filteredRegistrations = new WeakMap<CursorNativeToolRegistryApi, Set<NativeCursorToolName>>();
 
 function hasNonBuiltinTool(pi: Pick<ExtensionAPI, "getAllTools">, toolName: NativeCursorToolName): boolean {
 	const existingTool = pi.getAllTools().find((tool) => tool.name === toolName);
@@ -44,17 +48,29 @@ type NativeRegistrationContext = Pick<ExtensionContext, "mode" | "model"> & {
 function registerNativeCursorToolsFromSet(
 	pi: CursorNativeToolRegistryApi,
 	toolNames: readonly NativeCursorToolName[],
+	getCwd: () => string,
 ): NativeCursorToolName[] {
+	const state = getCursorNativeToolDisplayState(pi);
+	const { registeredNativeToolSources, skippedNativeToolNames } = state;
+	let filteredToolNames = filteredRegistrations.get(pi);
+	if (!filteredToolNames) {
+		filteredToolNames = new Set();
+		filteredRegistrations.set(pi, filteredToolNames);
+	}
 	const newlySkippedToolNames: NativeCursorToolName[] = [];
 	for (const toolName of toolNames) {
-		if (registeredNativeToolNames.has(toolName) || skippedNativeToolNames.has(toolName)) continue;
+		if (registeredNativeToolSources.has(toolName) || filteredToolNames.has(toolName)) continue;
 		if (hasNonBuiltinTool(pi, toolName)) {
-			skippedNativeToolNames.add(toolName);
-			newlySkippedToolNames.push(toolName);
+			if (!skippedNativeToolNames.has(toolName)) {
+				skippedNativeToolNames.add(toolName);
+				newlySkippedToolNames.push(toolName);
+			}
 			continue;
 		}
-		registerNativeCursorTool(pi, toolName);
-		registeredNativeToolNames.add(toolName);
+		registerNativeCursorTool(pi, toolName, getCwd, state);
+		const registeredTool = pi.getAllTools().find((tool) => tool.name === toolName);
+		if (registeredTool) registeredNativeToolSources.set(toolName, registeredTool.sourceInfo);
+		else filteredToolNames.add(toolName);
 	}
 	return newlySkippedToolNames;
 }
@@ -67,15 +83,12 @@ function notifySkippedNativeCursorToolsIfNeeded(ctx: NativeRegistrationContext,
 	);
 }
 
-function hasAttemptedNativeCursorToolRegistration(): boolean {
-	return registeredNativeToolNames.size > 0 || skippedNativeToolNames.size > 0;
-}
-
 function removeRegisteredNonCoreNativeCursorTools(pi: CursorNativeToolActivationApi): void {
-	if (registeredNativeToolNames.size === 0) return;
+	const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+	if (registeredNativeToolSources.size === 0) return;
 	const activeToolNames = new Set(pi.getActiveTools());
 	let changed = false;
-	for (const toolName of registeredNativeToolNames) {
+	for (const toolName of registeredNativeToolSources.keys()) {
 		if (isCursorCorePiReplayToolName(toolName)) continue;
 		if (!activeToolNames.delete(toolName)) continue;
 		changed = true;
@@ -87,7 +100,8 @@ export function syncRegisteredNativeCursorToolsForModel(
 	pi: CursorNativeToolActivationApi,
 	model: ExtensionContext["model"],
 ): void {
-	if (registeredNativeToolNames.size === 0) return;
+	const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+	if (registeredNativeToolSources.size === 0) return;
 	if (!isCursorModel(model)) {
 		removeRegisteredNonCoreNativeCursorTools(pi);
 		return;
@@ -95,7 +109,7 @@ export function syncRegisteredNativeCursorToolsForModel(
 	if (arePiToolsDisabled(pi)) return;
 	const activeToolNames = new Set(pi.getActiveTools());
 	let changed = false;
-	for (const toolName of registeredNativeToolNames) {
+	for (const toolName of registeredNativeToolSources.keys()) {
 		if (isCursorReplayToolName(toolName) && !CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES.some((activeReplayToolName) => activeReplayToolName === toolName)) continue;
 		if (activeToolNames.has(toolName)) continue;
 		activeToolNames.add(toolName);
@@ -104,31 +118,41 @@ export function syncRegisteredNativeCursorToolsForModel(
 	if (changed) pi.setActiveTools([...activeToolNames]);
 }
 
-function ensureNativeCursorToolsRegisteredForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext): void {
-	if (!isCursorModel(ctx.model) || hasAttemptedNativeCursorToolRegistration()) return;
+function ensureNativeCursorToolsRegisteredForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext, getCwd: () => string): void {
+	if (!isCursorModel(ctx.model)) return;
 
 	const nonCoreToolNames = NATIVE_CURSOR_TOOL_NAMES.filter((toolName) => !isCursorCorePiReplayToolName(toolName));
 	const skippedToolNames = [
-		...registerNativeCursorToolsFromSet(pi, nonCoreToolNames),
-		...registerNativeCursorToolsFromSet(pi, CURSOR_CORE_PI_REPLAY_TOOL_NAMES),
+		...registerNativeCursorToolsFromSet(pi, nonCoreToolNames, getCwd),
+		...registerNativeCursorToolsFromSet(pi, CURSOR_CORE_PI_REPLAY_TOOL_NAMES, getCwd),
 	];
 	notifySkippedNativeCursorToolsIfNeeded(ctx, skippedToolNames);
 }
 
-function ensureThenSyncNativeCursorToolsForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext): void {
+function ensureThenSyncNativeCursorToolsForModel(pi: CursorNativeToolRegistryApi, ctx: NativeRegistrationContext, getCwd: () => string): void {
+	const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+	const currentTools = pi.getAllTools();
+	for (const [toolName, sourceInfo] of registeredNativeToolSources) {
+		if (!currentTools.some((tool) => tool.name === toolName && tool.sourceInfo === sourceInfo)) {
+			registeredNativeToolSources.delete(toolName);
+		}
+	}
 	const requested = isCursorNativeToolRegistrationRequested(ctx.mode);
-	setCursorNativeToolDisplayRuntimeRequested(requested);
+	setCursorNativeToolDisplayRuntimeRequested(requested, pi);
 	if (!requested) {
 		removeRegisteredNonCoreNativeCursorTools(pi);
 		return;
 	}
-	ensureNativeCursorToolsRegisteredForModel(pi, ctx);
+	ensureNativeCursorToolsRegisteredForModel(pi, ctx, getCwd);
 	syncRegisteredNativeCursorToolsForModel(pi, ctx.model);
 }
 
 export function registerCursorNativeToolDisplay(pi: CursorNativeToolDisplayExtensionApi): void {
+	registerCursorNativeToolDisplayState(pi);
+	let cwd = process.cwd();
 	registerCursorModelLifecycle(pi, (ctx) => {
-		ensureThenSyncNativeCursorToolsForModel(pi, ctx);
+		cwd = ctx.cwd;
+		ensureThenSyncNativeCursorToolsForModel(pi, ctx, () => cwd);
 	});
 }
 

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

@@ -1,5 +1,7 @@
+import type { ExtensionHandler, SessionShutdownEvent, SourceInfo } from "@earendil-works/pi-coding-agent";
 import type { CursorPiToolDisplay } from "./cursor-transcript-utils.js";
 import { parseOptionalEnvBoolean } from "./cursor-env-boolean.js";
+import { normalizeCursorToolName } from "./cursor-tool-presentation-registry.js";
 
 export interface CursorNativeToolDisplayItem extends CursorPiToolDisplay {
 	id: string;
@@ -9,11 +11,43 @@ export interface CursorNativeToolDisplayItem extends CursorPiToolDisplay {
 export const NATIVE_CURSOR_TOOL_DISPLAY_ENV = "PI_CURSOR_NATIVE_TOOL_DISPLAY";
 export const NATIVE_CURSOR_TOOL_REGISTRATION_ENV = "PI_CURSOR_REGISTER_NATIVE_TOOLS";
 
-export const registeredNativeToolNames = new Set<string>();
-export const skippedNativeToolNames = new Set<string>();
+export interface CursorNativeToolDisplayState {
+	registeredNativeToolSources: Map<string, SourceInfo>;
+	skippedNativeToolNames: Set<string>;
+	runtimeRequested: boolean;
+	resultIds: Set<string>;
+}
+
+function createDisplayState(): CursorNativeToolDisplayState {
+	return { registeredNativeToolSources: new Map(), skippedNativeToolNames: new Set(), runtimeRequested: false, resultIds: new Set() };
+}
+
+let lastDisplayState = createDisplayState();
+const displayStates = new Map<object, CursorNativeToolDisplayState>();
+// IDs index results; the owning display state and tool authorize consumption.
 export const nativeToolResults = new Map<string, CursorNativeToolDisplayItem>();
+const resultStates = new Map<string, CursorNativeToolDisplayState>();
 
-let nativeToolDisplayRuntimeRequested = false;
+export function getCursorNativeToolDisplayState(pi?: object): CursorNativeToolDisplayState {
+	if (!pi) return lastDisplayState;
+	const state = displayStates.get(pi);
+	if (!state) throw new Error("Cursor native display binding is no longer active.");
+	return state;
+}
+
+export function registerCursorNativeToolDisplayState(pi: { on(event: "session_shutdown", handler: ExtensionHandler<SessionShutdownEvent>): void }): void {
+	const state = createDisplayState();
+	displayStates.set(pi, state);
+	lastDisplayState = state;
+	pi.on("session_shutdown", () => {
+		displayStates.delete(pi);
+		for (const id of state.resultIds) {
+			nativeToolResults.delete(id);
+			resultStates.delete(id);
+		}
+		state.resultIds.clear();
+	});
+}
 
 export function readBooleanEnv(name: string, env: Record<string, string | undefined> = process.env): boolean | undefined {
 	return parseOptionalEnvBoolean(env[name]);
@@ -30,39 +64,48 @@ export function isCursorNativeToolRegistrationRequested(mode?: string): boolean
 	return mode !== "print" && readBooleanEnv(NATIVE_CURSOR_TOOL_REGISTRATION_ENV) !== false && isCursorNativeToolDisplayRequested(mode);
 }
 
-export function setCursorNativeToolDisplayRuntimeRequested(requested: boolean): void {
-	nativeToolDisplayRuntimeRequested = requested;
+export function setCursorNativeToolDisplayRuntimeRequested(requested: boolean, pi?: object): void {
+	getCursorNativeToolDisplayState(pi).runtimeRequested = requested;
 }
 
 export function isCursorNativeToolDisplayEnabled(): boolean {
-	return registeredNativeToolNames.size > 0;
+	return getCursorNativeToolDisplayState().registeredNativeToolSources.size > 0;
 }
 
-export function isCursorNativeToolDisplayRuntimeEnabled(): boolean {
-	return nativeToolDisplayRuntimeRequested && readBooleanEnv(NATIVE_CURSOR_TOOL_DISPLAY_ENV) !== false && registeredNativeToolNames.size > 0;
+export function isCursorNativeToolDisplayRuntimeEnabled(state = getCursorNativeToolDisplayState()): boolean {
+	return state.runtimeRequested && readBooleanEnv(NATIVE_CURSOR_TOOL_DISPLAY_ENV) !== false && state.registeredNativeToolSources.size > 0;
 }
 
 export function canRenderCursorToolNatively(toolName: string): boolean {
-	return registeredNativeToolNames.has(toolName);
+	return getCursorNativeToolDisplayState().registeredNativeToolSources.has(toolName);
 }
 
-export function isRegisteredCursorNativeToolName(toolName: string): boolean {
-	return registeredNativeToolNames.has(toolName);
+export function isRegisteredCursorNativeToolName(toolName: string, pi?: object): boolean {
+	return (pi ? displayStates.get(pi) : lastDisplayState)?.registeredNativeToolSources.has(toolName) === true;
 }
 
-export function recordCursorNativeToolDisplay(item: CursorNativeToolDisplayItem): boolean {
-	if (!canRenderCursorToolNatively(item.toolName)) return false;
+export function recordCursorNativeToolDisplay(item: CursorNativeToolDisplayItem, state = getCursorNativeToolDisplayState()): boolean {
+	if (!state.registeredNativeToolSources.has(item.toolName)) return false;
 	nativeToolResults.set(item.id, item);
+	resultStates.set(item.id, state);
+	state.resultIds.add(item.id);
 	return true;
 }
 
 export function deleteCursorNativeToolDisplay(id: string): void {
 	nativeToolResults.delete(id);
+	resultStates.get(id)?.resultIds.delete(id);
+	resultStates.delete(id);
 }
 
-export function consumeCursorNativeToolDisplay(id: string): CursorNativeToolDisplayItem | undefined {
+export function consumeCursorNativeToolDisplay(id: string, state: CursorNativeToolDisplayState, toolName: string): CursorNativeToolDisplayItem | undefined {
 	const item = nativeToolResults.get(id);
-	if (item) nativeToolResults.delete(id);
+	if (item) {
+		if (resultStates.get(id) !== state || normalizeCursorToolName(item.toolName) !== normalizeCursorToolName(toolName)) {
+			throw new Error(`No owned Cursor ${toolName} result was available. This replay-only call does not execute work.`);
+		}
+		deleteCursorNativeToolDisplay(id);
+	}
 	return item;
 }
 
@@ -76,14 +119,15 @@ export function isCursorFileMutationToolName(toolName: string): toolName is "edi
 
 export const __testUtils = {
 	nativeToolResultCount: () => nativeToolResults.size,
-	registerNativeToolNameForTests(toolName: string): void {
-		nativeToolDisplayRuntimeRequested = true;
-		registeredNativeToolNames.add(toolName);
+	registerNativeToolNameForTests(toolName: string, pi?: object): void {
+		const state = getCursorNativeToolDisplayState(pi);
+		state.runtimeRequested = true;
+		state.registeredNativeToolSources.set(toolName, { path: "test", source: "inline", scope: "temporary", origin: "top-level" });
 	},
 	reset(): void {
-		nativeToolDisplayRuntimeRequested = false;
-		registeredNativeToolNames.clear();
-		skippedNativeToolNames.clear();
+		lastDisplayState = createDisplayState();
+		displayStates.clear();
 		nativeToolResults.clear();
+		resultStates.clear();
 	},
 };

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

@@ -10,7 +10,6 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import type { TSchema } from "typebox";
-import { getCursorSessionCwd } from "./cursor-session-scope.js";
 import {
 	BUILTIN_NATIVE_CURSOR_TOOL_NAMES,
 	CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES,
@@ -33,6 +32,7 @@ import {
 import {
 	consumeCursorNativeToolDisplay,
 	isCursorReplayToolCallId,
+	type CursorNativeToolDisplayState,
 } from "./cursor-native-tool-display-state.js";
 
 
@@ -155,12 +155,13 @@ function getNativeReplayStrategy(toolName: string): NativeReplayStrategy | undef
 export function wrapNativeCursorTool<TParams extends TSchema, TDetails, TState>(
 	definition: ToolDefinition<TParams, TDetails, TState>,
 	getCurrentDefinition: () => ToolDefinition<TParams, TDetails, TState>,
+	state: CursorNativeToolDisplayState,
 ): ToolDefinition<TParams, TDetails, TState> {
 	const strategy = getNativeReplayStrategy(definition.name);
 	return {
 		...definition,
 		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			const cursorDisplay = consumeCursorNativeToolDisplay(toolCallId);
+			const cursorDisplay = consumeCursorNativeToolDisplay(toolCallId, state, definition.name);
 			if (cursorDisplay) {
 				if (cursorDisplay.isError) {
 					const text = cursorDisplay.result.content
@@ -211,9 +212,11 @@ export function createNativeCursorToolDefinition(toolName: NativeCursorToolName,
 export function registerNativeCursorTool(
 	pi: Pick<import("@earendil-works/pi-coding-agent").ExtensionAPI, "registerTool">,
 	toolName: NativeCursorToolName,
+	getCwd: () => string,
+	state: CursorNativeToolDisplayState,
 ): void {
-	const definition = createNativeCursorToolDefinition(toolName, getCursorSessionCwd());
-	pi.registerTool(wrapNativeCursorTool(definition, () => createNativeCursorToolDefinition(toolName, getCursorSessionCwd())));
+	const definition = createNativeCursorToolDefinition(toolName, getCwd());
+	pi.registerTool(wrapNativeCursorTool(definition, () => createNativeCursorToolDefinition(toolName, getCwd()), state));
 }
 
 export { CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES, CURSOR_REPLAY_TOOL_NAMES };

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

@@ -1,8 +1,33 @@
 export const MCP_SERVER_NAME = "pi_tools";
 export const MCP_ENDPOINT_ROOT = "/cursor-pi-tool-bridge";
+export const CURSOR_PI_BRIDGE_TOOL_CALL_ID_MAX_LENGTH = 64;
 
-const CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN = /^cursor-pi-bridge-run-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}-tool-\d+$/i;
+const CURSOR_PI_BRIDGE_RUN_UUID_PATTERN = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+const CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN = /^cursor-pi-bridge-[0-9a-f]{32}-t\d+$/i;
+const LEGACY_CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN =
+	/^cursor-pi-bridge-run-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}-tool-\d+$/i;
+
+/**
+ * Build the provider-facing bridge ID while enforcing the 64-character
+ * call_id limit used by OpenAI-compatible Responses backends.
+ */
+export function buildCursorPiBridgeToolCallId(runUuid: string, counter: number): string {
+	if (!CURSOR_PI_BRIDGE_RUN_UUID_PATTERN.test(runUuid)) {
+		throw new Error("Cursor pi bridge run UUID must be canonical");
+	}
+	if (!Number.isSafeInteger(counter) || counter <= 0) {
+		throw new Error("Cursor pi bridge tool call counter must be a positive safe integer");
+	}
+	const toolCallId = `cursor-pi-bridge-${runUuid.replaceAll("-", "")}-t${counter}`;
+	if (toolCallId.length > CURSOR_PI_BRIDGE_TOOL_CALL_ID_MAX_LENGTH) {
+		throw new Error("Cursor pi bridge tool call ID limit exceeded");
+	}
+	return toolCallId;
+}
 
 export function isCursorPiBridgeToolCallId(toolCallId: string): boolean {
-	return CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN.test(toolCallId);
+	return (
+		(toolCallId.length <= CURSOR_PI_BRIDGE_TOOL_CALL_ID_MAX_LENGTH && CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN.test(toolCallId)) ||
+		LEGACY_CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN.test(toolCallId)
+	);
 }

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

@@ -7,7 +7,11 @@ import {
 	WebStandardStreamableHTTPServerTransport,
 } from "@modelcontextprotocol/server";
 import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
-import { MCP_ENDPOINT_ROOT, MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
+import {
+	buildCursorPiBridgeToolCallId,
+	MCP_ENDPOINT_ROOT,
+	MCP_SERVER_NAME,
+} from "./cursor-pi-tool-bridge-constants.js";
 import {
 	type CursorPiToolBridgeDiagnosticEvent,
 	type CursorPiToolBridgeLifecycleDiagnosticFields,
@@ -58,10 +62,12 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 	private readonly registry: CursorPiToolBridgeRunHost;
 	private readonly env: Record<string, string | undefined>;
 	private readonly endpointPath: string;
+	private readonly runUuid: string;
 	private readonly callTimeoutMs: number;
 	private readonly knownMcpToolNames: ReadonlySet<string>;
 	private readonly knownCursorMcpCallIds = new Set<string>();
 	private readonly queuedRequests: CursorPiBridgeToolRequest[] = [];
+	private readonly pendingToolCallListeners = new Set<() => void>();
 	private readonly pendingByPiToolCallId = new Map<string, PendingBridgeCall>();
 	private readonly pendingByBridgeCallId = new Map<string, PendingBridgeCall>();
 	private readonly pendingByCursorMcpCallId = new Map<string, PendingBridgeCall>();
@@ -86,7 +92,9 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		this.enabled = enabled;
 		this.onToolRequest = options.onToolRequest;
 		this.debugRecorder = options.debugRecorder;
-		this.id = `cursor-pi-bridge-run-${randomUUID()}`;
+		const runUuid = randomUUID();
+		this.runUuid = runUuid;
+		this.id = `cursor-pi-bridge-run-${runUuid}`;
 		this.endpointPath = `${MCP_ENDPOINT_ROOT}/${randomUUID()}/mcp`;
 		this.callTimeoutMs = resolveCursorPiToolBridgeCallTimeoutMs(env);
 		this.knownMcpToolNames = new Set(snapshot.tools.map((tool) => tool.mcpToolName));
@@ -183,6 +191,23 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		return this.pendingByPiToolCallId.has(piToolCallId);
 	}
 
+	hasPendingToolCalls(): boolean {
+		return this.pendingCount() > 0;
+	}
+
+	onPendingToolCallsChanged(listener: () => void): () => void {
+		this.pendingToolCallListeners.add(listener);
+		return () => { this.pendingToolCallListeners.delete(listener); };
+	}
+
+	private notifyPendingToolCallsChanged(): void {
+		for (const listener of this.pendingToolCallListeners) {
+			try { listener(); } catch {
+				// Observers must not prevent call registration or protocol settlement.
+			}
+		}
+	}
+
 	cancelPendingPiToolCallId(piToolCallId: string, reason: string): boolean {
 		const pending = this.pendingByPiToolCallId.get(piToolCallId);
 		if (!pending) return false;
@@ -227,6 +252,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		if (this.disposed) return;
 		this.disposed = true;
 		this.cancel("Cursor pi tool bridge run disposed");
+		this.pendingToolCallListeners.clear();
 		await waitForProtocolFlush();
 		await Promise.allSettled([
 			this.mcpTransport?.close(),
@@ -277,11 +303,12 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 
 		this.toolCallCounter += 1;
 		const bridgeCallId = `${this.id}-bridge-${this.toolCallCounter}`;
+		const piToolCallId = buildCursorPiBridgeToolCallId(this.runUuid, this.toolCallCounter);
 		const request: CursorPiBridgeToolRequest = {
 			runId: this.id,
 			bridgeCallId,
 			cursorMcpCallId,
-			piToolCallId: `${this.id}-tool-${this.toolCallCounter}`,
+			piToolCallId,
 			piToolName,
 			mcpToolName,
 			args: normalizeMcpArgs(argsValue),
@@ -307,6 +334,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 			this.pendingByBridgeCallId.set(request.bridgeCallId, pending);
 			this.pendingByCursorMcpCallId.set(cursorMcpCallId, pending);
 			this.knownCursorMcpCallIds.add(cursorMcpCallId);
+			this.notifyPendingToolCallsChanged();
 			pending.timeout = setTimeout(() => {
 				const reason = `Cursor pi bridge CallTool timed out after ${this.callTimeoutMs} ms`;
 				this.rejectAndAbortPending(pending, new Error(reason));
@@ -430,5 +458,6 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		if (pending.request.cursorMcpCallId) this.pendingByCursorMcpCallId.delete(pending.request.cursorMcpCallId);
 		const queuedIndex = this.queuedRequests.findIndex((request) => request.bridgeCallId === pending.request.bridgeCallId);
 		if (queuedIndex >= 0) this.queuedRequests.splice(queuedIndex, 1);
+		this.notifyPendingToolCallsChanged();
 	}
 }

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

@@ -7,7 +7,7 @@ import type {
 	CursorPiToolBridgeSnapshotApi,
 } from "./cursor-pi-tool-bridge-types.js";
 import { asRecord } from "./cursor-record-utils.js";
-import type { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
+import { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
 import {
 	buildCursorPiToolBridgeSnapshot,
 	buildCursorPiToolBridgeSurfaceSignature,
@@ -55,7 +55,6 @@ 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-snapshot.ts

@@ -63,7 +63,7 @@ export function buildCursorPiToolBridgeSnapshot(
 
 	for (const tool of allTools) {
 		if (!activeToolNames.has(tool.name)) continue;
-		if (isExcludedFromCursorBridgeExposure(tool.name) && isRegisteredCursorNativeToolName(tool.name)) continue;
+		if (isExcludedFromCursorBridgeExposure(tool.name) && isRegisteredCursorNativeToolName(tool.name, pi)) continue;
 		if (!exposeOverlappingBuiltins && isOverlappingCursorNativePiToolName(tool.name)) continue;
 
 		const mcpToolName = createMcpToolName(tool.name, usedMcpToolNames);