@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.1

package/dist/cursor-provider-turn-finalize.js

@@ -1,8 +1,5 @@
 import { loadCursorTranscriptWebToolCallsAfterOffset } from "./cursor-agent-message-web-tools.js";
-import { collectCursorCloudRunReport, formatCursorCloudRunReport, } 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 { isCursorRunFinishedSuccessfully, resolveCursorRunOutcome, } from "./cursor-provider-run-outcome.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import { attachCursorSdkBilledTurnUsage } from "./cursor-sdk-billed-usage.js";
@@ -39,7 +36,6 @@ export function buildCursorRunOutcomeFromWait(params) {
         runErrorFallback: params.runErrorFallback,
         resolvedApiKey: params.resolvedApiKey,
         optionsApiKey: params.optionsApiKey,
-        runtimeTarget: prepared.runtimeTarget,
     });
 }
 async function replayCursorTranscriptWebToolCalls(agentId, cwd, messageOffset, turnStore, turnCoordinator, sdkEventDebug) {
@@ -63,20 +59,8 @@ async function replayCursorTranscriptWebToolCalls(agentId, cwd, messageOffset, t
         sdkEventDebug?.recordError("cursor_transcript_web_tools", error);
     }
 }
-function scrubCursorCloudReportingError(error, apiKey) {
-    return new Error(scrubSensitiveText(error instanceof Error ? error.message : String(error), apiKey));
-}
-function recordCursorCloudReportingError(sdkEventDebug, error, apiKey) {
-    try {
-        sdkEventDebug?.recordError("cloud_run_report", scrubCursorCloudReportingError(error, apiKey));
-    }
-    catch {
-        // Debug reporting must never affect provider execution.
-    }
-}
 /** Single wait/finalize path for SDK runs: wait, debug capture, transcript replay, incomplete tools, artifacts, context cache. */
 export async function awaitFinalizeCursorRunOutcome(params) {
-    const apiKey = params.resolvedApiKey ?? params.optionsApiKey;
     const waitResult = params.waitResult ?? (await params.run.wait());
     const outcome = buildCursorRunOutcomeFromWait({
         waitResult,
@@ -90,54 +74,18 @@ export async function awaitFinalizeCursorRunOutcome(params) {
     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;
-    if (params.prepared.runtimeTarget === "cloud" && isCursorRunFinishedSuccessfully(outcome)) {
-        let report = { 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, params.cursorAgentMessageOffset, params.prepared.sessionAgentLease.store, params.prepared.runtime.turnCoordinator, params.sdkEventDebug);
     }
     params.prepared.runtime.turnCoordinator.discardIncompleteStartedToolCalls(outcome.incompleteTools);
@@ -147,8 +95,8 @@ export async function awaitFinalizeCursorRunOutcome(params) {
     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, params.prepared.cwd, params.prepared.sessionAgentLease.store);
     }
-    return { outcome, displayOnlyTraceBlock };
+    return { outcome };
 }

package/dist/cursor-provider-turn-prepare.js

@@ -1,52 +1,28 @@
 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, buildCursorSessionSendPrompt, planCursorSessionSend, resetSessionCursorAgent, } from "./cursor-session-agent.js";
-import { buildCursorPrompt, estimateCursorPromptTokens } from "./context.js";
+import { estimateCursorPromptTokens } from "./context.js";
 import { getCursorPromptOptions } from "./cursor-usage-accounting.js";
 import { getActiveContextToolNames } from "./cursor-context-tools.js";
-import { abandonSessionCursorAgent, createCursorNativeReplayId, cursorLiveRuns, getActiveCursorLiveRunForCurrentScope, getPendingCursorLiveRun, } from "./cursor-provider-live-run-drain.js";
+import { abandonSessionCursorAgent, createCursorNativeReplayId, cursorLiveRuns, } from "./cursor-provider-live-run-drain.js";
 import { getCursorProviderAgentModeOrThrow, getEffectiveFastForModelId, } from "./cursor-state.js";
 import { resolveEffectiveCursorConfig } from "./cursor-runtime-state.js";
 import { buildCursorBridgeExcludeToolNames } 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";
-function buildCursorCloudPromptContext(context, handoff) {
-    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 = { mode: "bootstrap", resetAgent: false, reason: "initial" };
 export function resolveCursorProviderTurnConfig(cwd) {
     return resolveEffectiveCursorConfig({ cwd, projectTrusted: getCursorSessionProjectTrusted() });
 }
-function buildCloudCursorProviderTurnLifecycle(agent) {
-    return {
-        trackRunCompletion: () => { },
-        commitSend: () => { },
-        abandon: async () => { },
-        dispose: async () => {
-            await agent[Symbol.asyncDispose]?.();
-        },
-    };
-}
 function buildLocalCursorProviderTurnLifecycle(lease, scopeKey) {
     return {
         trackRunCompletion: (completion) => lease.trackRunCompletion(completion),
@@ -55,115 +31,6 @@ function buildLocalCursorProviderTurnLifecycle(lease, scopeKey) {
         dispose: async () => { },
     };
 }
-async function prepareCursorCloudProviderTurn(prepareParams) {
-    const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
-    const { model, context, options } = params;
-    let restoreCursorSdkOutputFilter;
-    let cloudAgentForCleanup;
-    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 = [];
-        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) {
     const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled } = prepareParams;
     const { model, context, options } = params;
@@ -173,6 +40,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
     let completed = false;
     try {
         ensureCursorRipgrepPath();
+        ensureCursorTreeSitterVendorDir();
         const localSafety = {
             autoReview: resolvedConfig.local.autoReview.value,
             sandboxEnabled: resolvedConfig.local.sandboxEnabled.value,
@@ -315,7 +183,6 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
         });
         completed = true;
         return {
-            runtimeTarget: "local",
             agent,
             cwd,
             payload: sendPayload,
@@ -357,17 +224,14 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
         }
     }
 }
-/** Resolves the runtime target from the caller-supplied snapshot and dispatches to the owning branch. */
 export async function prepareCursorProviderTurn(prepareParams) {
-    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 = { ...prepareParams, agentMode, selection, fastEnabled };
-    return resolvedConfig.runtime.value === "cloud"
-        ? prepareCursorCloudProviderTurn(context)
-        : prepareCursorLocalProviderTurn(context);
+    return prepareCursorLocalProviderTurn(context);
 }
 export function requireCursorApiKey(options) {
     const apiKey = resolveCursorApiKey(options?.apiKey);

package/dist/cursor-provider-turn-runner.js

@@ -9,9 +9,9 @@ import { discardIncompleteToolsFromPrepared, emitCursorLiveTurn, } from "./curso
 import { CursorRunFinalizer } from "./cursor-provider-run-finalizer.js";
 import { prepareCursorProviderTurn, requireCursorApiKey, resolveCursorProviderTurnConfig, } from "./cursor-provider-turn-prepare.js";
 import { sendCursorProviderTurn } from "./cursor-provider-turn-send.js";
-function requireLocalLivePreparedTurn(prepared) {
-    if (prepared.runtimeTarget !== "local" || prepared.runtime.kind !== "live") {
-        throw new Error("Cursor live run requires a local live prepared turn");
+function requireLivePreparedTurn(prepared) {
+    if (prepared.runtime.kind !== "live") {
+        throw new Error("Cursor live run requires a live prepared turn");
     }
     return prepared;
 }
@@ -19,7 +19,6 @@ export class CursorProviderTurnRunner {
     params;
     sdkEventDebug;
     resolvedApiKey;
-    runtimeTarget;
     constructor(params) {
         this.params = params;
     }
@@ -40,7 +39,6 @@ export class CursorProviderTurnRunner {
             sdkEventDebug: () => this.sdkEventDebug,
             sdkProcessErrorGuard,
             resolvedApiKey: () => this.resolvedApiKey,
-            runtimeTarget: () => this.runtimeTarget,
         });
         try {
             this.throwIfAborted();
@@ -52,21 +50,12 @@ 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();
             this.resolvedApiKey = requireCursorApiKey(options);
@@ -84,11 +73,10 @@ 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,
@@ -122,7 +110,6 @@ export class CursorProviderTurnRunner {
                 kind: "direct",
                 prepared,
                 outcome: finalized.outcome,
-                displayOnlyTraceBlock: finalized.displayOnlyTraceBlock,
             });
         }
         catch (error) {
@@ -138,7 +125,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/dist/cursor-provider-turn-send.js

@@ -1,27 +1,8 @@
 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";
 import { recordCursorSessionAgentLineage } from "./cursor-session-agent-lineage.js";
-const CLOUD_LEDGER_CANCEL_TIMEOUT_MS = 5000;
-async function requestBoundedCloudRunCancellation(run) {
-    let timer;
-    const timeout = new Promise((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) {
     try {
         action();
@@ -31,7 +12,7 @@ function recordDebug(action) {
     }
 }
 export async function sendCursorProviderTurn(sendParams) {
-    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;
@@ -52,13 +33,11 @@ export async function sendCursorProviderTurn(sendParams) {
         abortRegistration?.signal.addEventListener("abort", abortListener, { once: true });
         throwIfAborted();
         let cursorAgentMessageOffset;
-        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({
@@ -89,20 +68,14 @@ export async function sendCursorProviderTurn(sendParams) {
             },
         };
         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,