@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.0

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

@@ -10,7 +10,6 @@ import {
 	resolveCursorSdkAbortCause,
 	sanitizeCursorProviderError,
 } from "./cursor-provider-errors.js";
-import type { CursorRuntime } from "./cursor-config.js";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import {
 	buildIncompleteCursorToolRunOutcome,
@@ -25,7 +24,6 @@ import type {
 	CursorProviderTurnSend,
 	CursorProviderTurnSendResult,
 	LiveCursorProviderTurnRuntime,
-	LocalCursorProviderTurnPrepareResult,
 } from "./cursor-provider-turn-types.js";
 import { applyCursorUsage } from "./cursor-usage-accounting.js";
 import { hasUsableText } from "./cursor-record-utils.js";
@@ -35,13 +33,12 @@ export type CursorTurnTerminalEvent =
 			kind: "direct";
 			prepared: CursorProviderTurnPrepareResult;
 			outcome: CursorRunOutcome;
-			displayOnlyTraceBlock?: string;
 	  }
 	| { kind: "error"; prepared: CursorProviderTurnPrepareResult | undefined; error: unknown };
 
 function applyLiveRunOutcome(
 	outcome: CursorRunOutcome,
-	prepared: LocalCursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime },
+	prepared: CursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime },
 	context: CursorProviderTurnRunnerParams["context"],
 ): void {
 	if (prepared.runtime.liveRun.disposed) return;
@@ -71,12 +68,11 @@ export interface CursorRunFinalizerParams {
 	sdkEventDebug: () => CursorSdkEventDebugSink | undefined;
 	sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>;
 	resolvedApiKey: () => string | undefined;
-	runtimeTarget: () => CursorRuntime | undefined;
 }
 
 export interface StartCursorLiveRunCompletionParams {
 	send: CursorProviderTurnSend;
-	prepared: LocalCursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime };
+	prepared: CursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime };
 	modelId: string;
 	discardIncompleteTools: (outcome: IncompleteCursorToolRunOutcomeInput) => void;
 }
@@ -114,7 +110,7 @@ export class CursorRunFinalizer {
 				if (!liveRun.disposed) {
 					cursorLiveRuns.markError(
 						liveRun,
-						sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey, "local"),
+						sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey),
 					);
 				}
 				this.safeCleanup(() => sdkEventDebug?.recordWaitResult({ status: "error", error: String(error) }));
@@ -129,7 +125,7 @@ export class CursorRunFinalizer {
 	async applyTerminalEvent(event: CursorTurnTerminalEvent): Promise<void> {
 		if (this.terminalApplied) return;
 		if (event.kind === "direct") {
-			await this.applyDirectOutcome(event.prepared, event.outcome, event.displayOnlyTraceBlock);
+			await this.applyDirectOutcome(event.prepared, event.outcome);
 			this.terminalApplied = true;
 			return;
 		}
@@ -165,7 +161,6 @@ export class CursorRunFinalizer {
 	private async applyDirectOutcome(
 		prepared: CursorProviderTurnPrepareResult,
 		outcome: CursorRunOutcome,
-		displayOnlyTraceBlock: string | undefined,
 	): Promise<void> {
 		const { stream, partial, model, context } = this.params.runnerParams;
 		prepared.runtime.turnCoordinator.closeTraceBlock();
@@ -184,12 +179,10 @@ export class CursorRunFinalizer {
 					outcome.kind === "finished" && hasUsableText(outcome.finalText) ? [outcome.finalText] : [],
 				);
 				applyCursorUsage(partial, model, context, prepared.meta.promptInputTokens, {
-					runtime: prepared.runtimeTarget,
 					turn: prepared.runtime.turnCoordinator.lastSdkTurnUsage,
 					billed: prepared.runtime.billedTurnUsage,
 				});
 				if (prepared.meta.resumeNotice) emitDisplayOnlyTraceBlock(stream, partial, prepared.meta.resumeNotice);
-				if (displayOnlyTraceBlock) emitDisplayOnlyTraceBlock(stream, partial, displayOnlyTraceBlock);
 				stream.push({ type: "done", reason: "stop", message: partial });
 				break;
 		}
@@ -219,7 +212,6 @@ export class CursorRunFinalizer {
 				sanitizeCursorProviderError(
 					error,
 					this.params.resolvedApiKey() ?? this.params.runnerParams.options?.apiKey,
-					prepared?.runtimeTarget ?? this.params.runtimeTarget(),
 				),
 			);
 		}

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

@@ -6,7 +6,6 @@ import {
 	resolveCursorSdkAbortCause,
 	sanitizeCursorProviderError,
 } from "./cursor-provider-errors.js";
-import type { CursorRuntime } from "./cursor-config.js";
 import { hasUsableText } from "./cursor-record-utils.js";
 import {
 	buildIncompleteCursorToolRunOutcome,
@@ -46,7 +45,6 @@ export interface ResolveCursorRunOutcomeParams {
 	runErrorFallback?: RunError;
 	resolvedApiKey?: string;
 	optionsApiKey?: string;
-	runtimeTarget: CursorRuntime;
 }
 
 function hasCursorAssistantText(
@@ -109,7 +107,6 @@ export function resolveCursorRunOutcome(params: ResolveCursorRunOutcomeParams):
 			errorMessage: sanitizeCursorProviderError(
 				failureDetail,
 				params.resolvedApiKey ?? params.optionsApiKey,
-				params.runtimeTarget,
 			),
 		};
 	}

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

@@ -1,13 +1,6 @@
 import type { LocalAgentStore, RunError, SDKAgent } from "@cursor/sdk";
 import { loadCursorTranscriptWebToolCallsAfterOffset } from "./cursor-agent-message-web-tools.js";
-import {
-	collectCursorCloudRunReport,
-	formatCursorCloudRunReport,
-	type CursorCloudRunReport,
-} from "./cursor-cloud-reporting.js";
-import { recordCursorCloudLifecycleRun } from "./cursor-cloud-lifecycle.js";
 import { getCheckpointContextWindow, saveCachedContextWindow } from "./context-window-cache.js";
-import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 import type { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import type { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
 import {
@@ -68,7 +61,6 @@ export function buildCursorRunOutcomeFromWait(params: BuildCursorRunOutcomeParam
 		runErrorFallback: params.runErrorFallback,
 		resolvedApiKey: params.resolvedApiKey,
 		optionsApiKey: params.optionsApiKey,
-		runtimeTarget: prepared.runtimeTarget,
 	});
 }
 
@@ -99,22 +91,6 @@ async function replayCursorTranscriptWebToolCalls(
 	}
 }
 
-function scrubCursorCloudReportingError(error: unknown, apiKey: string | undefined): Error {
-	return new Error(scrubSensitiveText(error instanceof Error ? error.message : String(error), apiKey));
-}
-
-function recordCursorCloudReportingError(
-	sdkEventDebug: CursorSdkEventDebugSink | undefined,
-	error: unknown,
-	apiKey: string | undefined,
-): void {
-	try {
-		sdkEventDebug?.recordError("cloud_run_report", scrubCursorCloudReportingError(error, apiKey));
-	} catch {
-		// Debug reporting must never affect provider execution.
-	}
-}
-
 export interface AwaitFinalizeCursorRunOutcomeParams {
 	run: Awaited<ReturnType<SDKAgent["send"]>>;
 	prepared: CursorProviderTurnPrepareResult;
@@ -134,12 +110,10 @@ export interface AwaitFinalizeCursorRunOutcomeParams {
 
 export interface FinalizedCursorRunOutcome {
 	outcome: CursorRunOutcome;
-	displayOnlyTraceBlock?: string;
 }
 
 /** Single wait/finalize path for SDK runs: wait, debug capture, transcript replay, incomplete tools, artifacts, context cache. */
 export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorRunOutcomeParams): Promise<FinalizedCursorRunOutcome> {
-	const apiKey = params.resolvedApiKey ?? params.optionsApiKey;
 	const waitResult = params.waitResult ?? (await params.run.wait());
 	const outcome = buildCursorRunOutcomeFromWait({
 		waitResult,
@@ -153,49 +127,17 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 	const billed = await attachCursorSdkBilledTurnUsage({
 		agent: params.prepared.agent,
 		agentId: params.run.agentId,
-		runtime: params.prepared.runtimeTarget,
-		runId: params.run.id,
 	});
 	params.prepared.runtime.billedTurnUsage = billed.turn;
 	if (params.prepared.runtime.liveRun) {
 		params.prepared.runtime.liveRun.billedTurnUsage = billed.turn;
 	}
-	let displayOnlyTraceBlock: string | undefined;
-	if (params.prepared.runtimeTarget === "cloud" && isCursorRunFinishedSuccessfully(outcome)) {
-		let report: CursorCloudRunReport = { agentId: params.run.agentId, runId: params.run.id, branches: [] };
-		try {
-			report = await collectCursorCloudRunReport({
-				agent: params.prepared.agent,
-				run: params.run,
-				waitResult,
-				apiKey,
-				agentUsage: billed.agentUsage,
-			});
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-		try {
-			recordCursorCloudLifecycleRun(report, { apiKey });
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-		try {
-			params.sdkEventDebug?.recordProviderEvent("cloud_run_report", report);
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-		try {
-			displayOnlyTraceBlock = formatCursorCloudRunReport(report, { apiKey });
-		} catch (error) {
-			recordCursorCloudReportingError(params.sdkEventDebug, error, apiKey);
-		}
-	}
 	try {
 		params.sdkEventDebug?.recordWaitResult(waitResult);
 	} catch {
 		// Debug reporting must never affect provider execution.
 	}
-	if (params.prepared.runtimeTarget === "local" && isCursorRunFinishedSuccessfully(outcome)) {
+	if (isCursorRunFinishedSuccessfully(outcome)) {
 		await replayCursorTranscriptWebToolCalls(
 			params.run.agentId,
 			params.prepared.cwd,
@@ -211,7 +153,7 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 	} catch {
 		// Debug artifact failures must never affect provider execution.
 	}
-	if (params.prepared.runtimeTarget === "local" && params.cacheContextWindow !== false) {
+	if (params.cacheContextWindow !== false) {
 		await cacheSdkContextWindow(
 			params.contextWindowAgentId ?? params.run.agentId,
 			params.modelId,
@@ -219,5 +161,5 @@ export async function awaitFinalizeCursorRunOutcome(params: AwaitFinalizeCursorR
 			params.prepared.sessionAgentLease.store,
 		);
 	}
-	return { outcome, displayOnlyTraceBlock };
+	return { outcome };
 }

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

@@ -1,8 +1,8 @@
 import type { Context, SimpleStreamOptions } from "@earendil-works/pi-ai";
-import type { AgentModeOption, ModelSelection, SDKAgent } from "@cursor/sdk";
+import type { AgentModeOption, ModelSelection } from "@cursor/sdk";
 import { configureCursorSdkHttp1 } from "./cursor-http1.js";
 import { installCursorMcpToolTimeoutOverride } from "./cursor-mcp-timeout-override.js";
-import { ensureCursorRipgrepPath } from "./cursor-ripgrep-path.js";
+import { ensureCursorRipgrepPath, ensureCursorTreeSitterVendorDir } from "./cursor-sdk-platform-package.js";
 import { installCursorSdkOutputFilter, suppressCursorSdkOutput } from "./cursor-sdk-output-filter.js";
 import {
 	acquireSessionCursorAgent,
@@ -31,33 +31,21 @@ import { resolveEffectiveCursorConfig } from "./cursor-runtime-state.js";
 import { buildCursorBridgeExcludeToolNames, type CursorResolvedSdkConfig } from "./cursor-config.js";
 import { buildCursorModelSelection } from "./model-discovery.js";
 import { getEffectiveCursorSettingSources } from "./cursor-setting-sources.js";
-import {
-	formatCursorCloudPreflightError,
-	buildCursorCloudAgentOptions,
-	preflightCursorCloudRuntime,
-} from "./cursor-cloud-options.js";
-import { inspectCursorCloudLocalState } from "./cursor-cloud-local-state.js";
-import { getCursorSessionName, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
+import { getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
 import {
 	buildCursorToolManifestText,
 	resolveCursorToolManifestEnabled,
 } from "./cursor-tool-manifest.js";
 import { isCursorNativeToolDisplayRuntimeEnabled } from "./cursor-native-tool-display-state.js";
-import {
-	createCursorCloudLifecyclePersistenceError,
-	recordCursorCloudLifecycleSafely,
-} from "./cursor-cloud-lifecycle.js";
 import { MISSING_CURSOR_API_KEY_MESSAGE } from "./cursor-provider-errors.js";
 import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
 import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import type {
-	CloudCursorProviderTurnPrepareResult,
 	CursorProviderTurnLifecycle,
 	CursorProviderTurnPrepareResult,
 	CursorProviderTurnRunnerParams,
-	LocalCursorProviderTurnPrepareResult,
 } from "./cursor-provider-turn-types.js";
 import type { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import type { SessionCursorAgentLease } from "./cursor-session-agent.js";
@@ -78,32 +66,10 @@ interface PrepareCursorProviderTurnContext extends PrepareCursorProviderTurnPara
 	fastEnabled: boolean | undefined;
 }
 
-function buildCursorCloudPromptContext(context: Context, handoff: "fresh" | "bootstrap" | "never"): Context {
-	if (handoff === "bootstrap") return context;
-	for (let index = context.messages.length - 1; index >= 0; index -= 1) {
-		const message = context.messages[index];
-		if (message.role === "user") return { ...context, messages: [message] };
-	}
-	return { ...context, messages: context.messages.slice(-1) };
-}
-
-const CLOUD_SEND_PLAN: CursorSessionSendPlan = { mode: "bootstrap", resetAgent: false, reason: "initial" };
-
 export function resolveCursorProviderTurnConfig(cwd: string) {
 	return resolveEffectiveCursorConfig({ cwd, projectTrusted: getCursorSessionProjectTrusted() });
 }
 
-function buildCloudCursorProviderTurnLifecycle(agent: SDKAgent): CursorProviderTurnLifecycle {
-	return {
-		trackRunCompletion: () => {},
-		commitSend: () => {},
-		abandon: async () => {},
-		dispose: async () => {
-			await agent[Symbol.asyncDispose]?.();
-		},
-	};
-}
-
 function buildLocalCursorProviderTurnLifecycle(
 	lease: SessionCursorAgentLease,
 	scopeKey: string,
@@ -116,129 +82,9 @@ function buildLocalCursorProviderTurnLifecycle(
 	};
 }
 
-async function prepareCursorCloudProviderTurn(
-	prepareParams: PrepareCursorProviderTurnContext,
-): Promise<CloudCursorProviderTurnPrepareResult> {
-	const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
-	const { model, context, options } = params;
-
-	let restoreCursorSdkOutputFilter: (() => void) | undefined;
-	let cloudAgentForCleanup: SDKAgent | undefined;
-	let completed = false;
-
-	try {
-		const preflight = preflightCursorCloudRuntime({
-			resolvedConfig,
-			localState: resolvedConfig.cloud.allowLocalState.value
-				? { insideGitRepo: false }
-				: inspectCursorCloudLocalState(cwd, {
-					repo: resolvedConfig.cloud.repo.value,
-					branch: resolvedConfig.cloud.branch.value,
-				}),
-			hasPriorContext: context.messages.length > 1,
-		});
-		if (!preflight.ok) throw new Error(formatCursorCloudPreflightError(preflight));
-		if (getPendingCursorLiveRun(context) || getActiveCursorLiveRunForCurrentScope()) {
-			throw new Error("Cursor cloud runtime cannot start while a local Cursor live run is pending; finish or abort the local run, then retry.");
-		}
-
-		const { Agent } = await loadCursorSdk();
-		restoreCursorSdkOutputFilter = installCursorSdkOutputFilter();
-		const promptOptions = {
-			...getCursorPromptOptions(model),
-			agentMode,
-			includePiBridgeGuidance: false,
-			includePiAskQuestionGuidance: false,
-		};
-		const prompt = buildCursorPrompt(
-			buildCursorCloudPromptContext(context, resolvedConfig.cloud.contextHandoff.value),
-			promptOptions,
-		);
-		const promptInputTokens = estimateCursorPromptTokens(prompt, promptOptions);
-		const agent = await suppressCursorSdkOutput(() =>
-			Agent.create(buildCursorCloudAgentOptions({
-				apiKey: resolvedApiKey,
-				modelSelection: selection,
-				agentMode,
-				resolvedConfig,
-				name: getCursorSessionName(),
-			})),
-		);
-		cloudAgentForCleanup = agent;
-		if (!recordCursorCloudLifecycleSafely({ agentId: agent.agentId }, resolvedApiKey)) {
-			throw createCursorCloudLifecyclePersistenceError(agent.agentId, "intent", undefined, resolvedApiKey);
-		}
-		sdkEventDebug?.recordProviderMeta({ runtime: "cloud", cloudAgentId: agent.agentId, phase: "agent_created" });
-		throwIfAborted();
-
-		const textDeltas: string[] = [];
-		const nativeReplayId = createCursorNativeReplayId();
-		const turnCoordinator = new CursorSdkTurnCoordinator({
-			stream: params.stream,
-			partial: params.partial,
-			cwd,
-			resolvedApiKey,
-			useNativeToolReplay: false,
-			nativeReplayId,
-			textDeltas,
-			debugRecorder: sdkEventDebug,
-		});
-		sdkEventDebug?.recordProviderMeta({
-			runtime: "cloud",
-			cloudAgentId: agent.agentId,
-			model: {
-				id: model.id,
-				provider: model.provider,
-				api: model.api,
-				reasoning: options?.reasoning ?? "off",
-				fastEnabled,
-				selection,
-			},
-			contextHandoff: resolvedConfig.cloud.contextHandoff.value,
-			sendPlan: CLOUD_SEND_PLAN,
-			promptOptions,
-			agentMode,
-			localForce: false,
-		});
-
-		completed = true;
-		cloudAgentForCleanup = undefined;
-		return {
-			runtimeTarget: "cloud",
-			agent,
-			cwd,
-			payload: {
-				text: prompt.text,
-				images: prompt.images.length > 0 ? prompt.images : undefined,
-			},
-			meta: {
-				sendPlan: CLOUD_SEND_PLAN,
-				prompt,
-				bootstrap: true,
-				promptInputTokens,
-				useNativeToolReplay: false,
-				bridgeEnabled: false,
-				nativeReplayId,
-				agentMode,
-				modelSelection: selection,
-			},
-			contextWindowAgentId: agent.agentId,
-			textDeltas,
-			restoreCursorSdkOutputFilter,
-			lifecycle: buildCloudCursorProviderTurnLifecycle(agent),
-			runtime: { kind: "direct", turnCoordinator },
-		};
-	} finally {
-		if (!completed) {
-			await cloudAgentForCleanup?.[Symbol.asyncDispose]?.().catch(() => {});
-			restoreCursorSdkOutputFilter?.();
-		}
-	}
-}
-
 async function prepareCursorLocalProviderTurn(
 	prepareParams: PrepareCursorProviderTurnContext,
-): Promise<LocalCursorProviderTurnPrepareResult> {
+): Promise<CursorProviderTurnPrepareResult> {
 	const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
 	const { model, context, options } = params;
 
@@ -249,6 +95,7 @@ async function prepareCursorLocalProviderTurn(
 
 	try {
 		ensureCursorRipgrepPath();
+		ensureCursorTreeSitterVendorDir();
 		const localSafety = {
 			autoReview: resolvedConfig.local.autoReview.value,
 			sandboxEnabled: resolvedConfig.local.sandboxEnabled.value,
@@ -398,7 +245,6 @@ async function prepareCursorLocalProviderTurn(
 
 		completed = true;
 		return {
-			runtimeTarget: "local",
 			agent,
 			cwd,
 			payload: sendPayload,
@@ -439,21 +285,18 @@ async function prepareCursorLocalProviderTurn(
 	}
 }
 
-/** Resolves the runtime target from the caller-supplied snapshot and dispatches to the owning branch. */
 export async function prepareCursorProviderTurn(
 	prepareParams: PrepareCursorProviderTurnParams,
 ): Promise<CursorProviderTurnPrepareResult> {
-	const { params, resolvedConfig } = prepareParams;
+	const { params } = prepareParams;
 	const { model, options } = params;
 
 	const agentMode = getCursorProviderAgentModeOrThrow();
-	const fastEnabled = resolvedConfig.runtime.value === "cloud" ? undefined : getEffectiveFastForModelId(model.id);
+	const fastEnabled = getEffectiveFastForModelId(model.id);
 	const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
 	const context: PrepareCursorProviderTurnContext = { ...prepareParams, agentMode, selection, fastEnabled };
 
-	return resolvedConfig.runtime.value === "cloud"
-		? prepareCursorCloudProviderTurn(context)
-		: prepareCursorLocalProviderTurn(context);
+	return prepareCursorLocalProviderTurn(context);
 }
 
 export function requireCursorApiKey(options: SimpleStreamOptions | undefined): string {

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

@@ -3,7 +3,6 @@ import { drainExistingCursorLiveRunBeforeSend } from "./cursor-provider-live-run
 import { invalidateSessionAgent } from "./cursor-session-agent.js";
 import { getCursorSessionCwd, getCursorSessionScopeKey } from "./cursor-session-scope.js";
 import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
-import type { CursorRuntime } from "./cursor-config.js";
 import { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
 import {
@@ -22,24 +21,22 @@ import type {
 	CursorProviderTurnRunnerParams,
 	CursorProviderTurnSendResult,
 	LiveCursorProviderTurnRuntime,
-	LocalCursorProviderTurnPrepareResult,
 } from "./cursor-provider-turn-types.js";
 
 export type { CursorProviderTurnRunnerParams } from "./cursor-provider-turn-types.js";
 
-type LocalLivePreparedTurn = LocalCursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime };
+type LivePreparedTurn = CursorProviderTurnPrepareResult & { runtime: LiveCursorProviderTurnRuntime };
 
-function requireLocalLivePreparedTurn(prepared: CursorProviderTurnPrepareResult): LocalLivePreparedTurn {
-	if (prepared.runtimeTarget !== "local" || prepared.runtime.kind !== "live") {
-		throw new Error("Cursor live run requires a local live prepared turn");
+function requireLivePreparedTurn(prepared: CursorProviderTurnPrepareResult): LivePreparedTurn {
+	if (prepared.runtime.kind !== "live") {
+		throw new Error("Cursor live run requires a live prepared turn");
 	}
-	return prepared as LocalLivePreparedTurn;
+	return prepared as LivePreparedTurn;
 }
 
 export class CursorProviderTurnRunner {
 	private sdkEventDebug: CursorSdkEventDebugSink | undefined;
 	private resolvedApiKey: string | undefined;
-	private runtimeTarget: CursorRuntime | undefined;
 
 	constructor(private readonly params: CursorProviderTurnRunnerParams) {}
 
@@ -61,7 +58,6 @@ export class CursorProviderTurnRunner {
 			sdkEventDebug: () => this.sdkEventDebug,
 			sdkProcessErrorGuard,
 			resolvedApiKey: () => this.resolvedApiKey,
-			runtimeTarget: () => this.runtimeTarget,
 		});
 
 		try {
@@ -74,25 +70,16 @@ export class CursorProviderTurnRunner {
 			});
 			sdkEventDebugRef.current = this.sdkEventDebug;
 			this.sdkEventDebug?.recordContextSnapshot(context);
-			// Resolved once here, before any drain await, so the drain decision and the
-			// prepare dispatch below always act on the same config snapshot.
 			const resolvedConfig = resolveCursorProviderTurnConfig(cwd);
-			this.runtimeTarget = resolvedConfig.runtime.value;
-			if (resolvedConfig.runtime.value === "local") {
-				// The observed local-executor closed-pipe EPIPE is contained only from this
-				// turn's pre-send live-run drain through run completion; for live runs the
-				// finalizer holds the guard until run.wait() settles. A hit marks
-				// this scope's pooled agent transport dead so the next acquire recreates it.
-				const localScopeKey = getCursorSessionScopeKey();
-				sdkProcessErrorGuard.containLocalTransportClosedPipe(() =>
-					invalidateSessionAgent(localScopeKey, { deadTransport: true }),
-				);
-				if (
-					(await drainExistingCursorLiveRunBeforeSend(stream, partial, model, context, options?.signal, this.sdkEventDebug)) ===
-					"stream_ended"
-				) {
-					return;
-				}
+			const localScopeKey = getCursorSessionScopeKey();
+			sdkProcessErrorGuard.containLocalTransportClosedPipe(() =>
+				invalidateSessionAgent(localScopeKey, { deadTransport: true }),
+			);
+			if (
+				(await drainExistingCursorLiveRunBeforeSend(stream, partial, model, context, options?.signal, this.sdkEventDebug)) ===
+				"stream_ended"
+			) {
+				return;
 			}
 			this.throwIfAborted();
 
@@ -112,12 +99,11 @@ export class CursorProviderTurnRunner {
 				sdkEventDebug: this.sdkEventDebug,
 				sdkProcessErrorGuard,
 				throwIfAborted: () => this.throwIfAborted(),
-				resolvedApiKey: this.resolvedApiKey,
 			});
 			const { send } = sendResult;
 
 			if (prepared.runtime.kind === "live") {
-				const livePrepared = requireLocalLivePreparedTurn(prepared);
+				const livePrepared = requireLivePreparedTurn(prepared);
 				liveCompletion = runFinalizer.startLiveRunCompletion({
 					send,
 					prepared: livePrepared,
@@ -152,7 +138,6 @@ export class CursorProviderTurnRunner {
 				kind: "direct",
 				prepared,
 				outcome: finalized.outcome,
-				displayOnlyTraceBlock: finalized.displayOnlyTraceBlock,
 			});
 		} catch (error) {
 			await runFinalizer.applyTerminalEvent({ kind: "error", prepared, error });
@@ -167,7 +152,6 @@ export class CursorProviderTurnRunner {
 			sdkEventDebug: () => this.sdkEventDebug,
 			sdkProcessErrorGuard: installCursorSdkProcessErrorGuard(),
 			resolvedApiKey: () => this.resolvedApiKey,
-			runtimeTarget: () => this.runtimeTarget,
 		});
 		await runFinalizer.applyTerminalEvent({ kind: "error", prepared: undefined, error });
 		await runFinalizer.cleanup(undefined, undefined, undefined);

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

@@ -1,9 +1,5 @@
 import type { SendOptions } from "@cursor/sdk";
 import { countCursorAgentMessages } from "./cursor-agent-message-web-tools.js";
-import {
-	createCursorCloudLifecyclePersistenceError,
-	recordCursorCloudLifecycleSafely,
-} from "./cursor-cloud-lifecycle.js";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import { consumeCursorLocalForceOverride } from "./cursor-runtime-state.js";
@@ -22,25 +18,6 @@ export interface SendCursorProviderTurnParams {
 	sdkEventDebug: CursorSdkEventDebugSink | undefined;
 	sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>;
 	throwIfAborted: () => void;
-	resolvedApiKey?: string;
-}
-
-const CLOUD_LEDGER_CANCEL_TIMEOUT_MS = 5000;
-
-async function requestBoundedCloudRunCancellation(run: Awaited<ReturnType<CursorProviderTurnPrepareResult["agent"]["send"]>>): Promise<boolean> {
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	const timeout = new Promise<false>((resolve) => {
-		timer = setTimeout(() => resolve(false), CLOUD_LEDGER_CANCEL_TIMEOUT_MS);
-		timer.unref?.();
-	});
-	try {
-		return await Promise.race([
-			Promise.resolve().then(() => run.cancel()).then(() => true, () => false),
-			timeout,
-		]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
 }
 
 function recordDebug(action: () => void): void {
@@ -52,7 +29,7 @@ function recordDebug(action: () => void): void {
 }
 
 export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnParams): Promise<CursorProviderTurnSendResult> {
-	const { params, prepared, sdkEventDebug, sdkProcessErrorGuard, throwIfAborted, resolvedApiKey } = sendParams;
+	const { params, prepared, sdkEventDebug, sdkProcessErrorGuard, throwIfAborted } = sendParams;
 	const { options } = params;
 	const { agent, cwd, payload, meta, runtime } = prepared;
 	const { turnCoordinator, liveRun } = runtime;
@@ -75,12 +52,10 @@ export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnP
 		abortRegistration?.signal.addEventListener("abort", abortListener, { once: true });
 		throwIfAborted();
 		let cursorAgentMessageOffset: number | undefined;
-		if (prepared.runtimeTarget === "local") {
-			try {
-				cursorAgentMessageOffset = await countCursorAgentMessages(agent.agentId, cwd, prepared.sessionAgentLease.store);
-			} catch (error) {
-				recordDebug(() => sdkEventDebug?.recordError("cursor_agent_message_count", error));
-			}
+		try {
+			cursorAgentMessageOffset = await countCursorAgentMessages(agent.agentId, cwd, prepared.sessionAgentLease.store);
+		} catch (error) {
+			recordDebug(() => sdkEventDebug?.recordError("cursor_agent_message_count", error));
 		}
 		throwIfAborted();
 		recordDebug(() => sdkEventDebug?.recordSendMeta({
@@ -111,20 +86,14 @@ export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnP
 			},
 		};
 		throwIfAborted();
-		if (prepared.runtimeTarget === "local" && consumeCursorLocalForceOverride(prepared.localForce)) {
+		if (consumeCursorLocalForceOverride(prepared.localForce)) {
 			sendOptions.local = { force: true };
 		}
 		const runPromise = agent.send(payload, sendOptions);
 		// Record at send initiation (promise created), including later reject/cancel paths.
-		if (prepared.runtimeTarget === "local") {
-			recordCursorSessionAgentLineage(agent.agentId);
-		}
+		recordCursorSessionAgentLineage(agent.agentId);
 		const run = await runPromise;
 		sdkRun = run;
-		if (prepared.runtimeTarget === "cloud" && !recordCursorCloudLifecycleSafely({ agentId: run.agentId, runId: run.id }, resolvedApiKey)) {
-			const cancellationConfirmed = await requestBoundedCloudRunCancellation(run);
-			throw createCursorCloudLifecyclePersistenceError(run.agentId, "run", cancellationConfirmed, resolvedApiKey);
-		}
 		recordDebug(() => sdkEventDebug?.recordRunMeta({
 			runId: run.id,
 			requestId: run.requestId,