@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.0

package/dist/cursor-config.js

@@ -5,19 +5,6 @@ import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { parseOptionalEnvBoolean } from "./cursor-env-boolean.js";
 import { asRecord } from "./cursor-record-utils.js";
 export const CURSOR_SDK_CONFIG_FILE = "cursor-sdk.json";
-export const CURSOR_RUNTIME_ENV = "PI_CURSOR_RUNTIME";
-export const CURSOR_CLOUD_REPO_ENV = "PI_CURSOR_CLOUD_REPO";
-export const CURSOR_CLOUD_BRANCH_ENV = "PI_CURSOR_CLOUD_BRANCH";
-export const CURSOR_CLOUD_CONTEXT_ENV = "PI_CURSOR_CLOUD_CONTEXT";
-export const CURSOR_CLOUD_DIRECT_PUSH_ENV = "PI_CURSOR_CLOUD_DIRECT_PUSH";
-export const CURSOR_CLOUD_AUTO_CREATE_PR_ENV = "PI_CURSOR_CLOUD_AUTO_CREATE_PR";
-export const CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV = "PI_CURSOR_CLOUD_SKIP_REVIEWER_REQUEST";
-export const CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV = "PI_CURSOR_CLOUD_ALLOW_LOCAL_STATE";
-export const CURSOR_CLOUD_ENV_ENV = "PI_CURSOR_CLOUD_ENV";
-export const CURSOR_CLOUD_ENV_FROM_FILES_ENV = "PI_CURSOR_CLOUD_ENV_FROM_FILES";
-export const CURSOR_CLOUD_ENV_TYPE_ENV = "PI_CURSOR_CLOUD_ENV_TYPE";
-export const CURSOR_CLOUD_ENV_NAME_ENV = "PI_CURSOR_CLOUD_ENV_NAME";
-export const CURSOR_CLOUD_ACK_ENV = "PI_CURSOR_CLOUD_ACK";
 export const CURSOR_AUTO_REVIEW_ENV = "PI_CURSOR_AUTO_REVIEW";
 export const CURSOR_SANDBOX_ENV = "PI_CURSOR_SANDBOX";
 export const CURSOR_LOCAL_FORCE_ENV = "PI_CURSOR_LOCAL_FORCE";
@@ -32,28 +19,6 @@ const TRUST_LEVELS = {
     "model-alias": "model-catalog",
     builtin: "builtin",
 };
-const BUILT_IN_CURSOR_CONFIG = {
-    runtime: "local",
-    cloud: {
-        repo: "",
-        branch: "",
-        contextHandoff: "fresh",
-        directPush: false,
-        autoCreatePR: false,
-        skipReviewerRequest: false,
-        allowLocalState: false,
-        envNames: [],
-        envFromFiles: false,
-        environment: {},
-        acknowledged: false,
-    },
-};
-export function isCursorRuntime(value) {
-    return value === "local" || value === "cloud";
-}
-export function isCursorCloudContextHandoff(value) {
-    return value === "never" || value === "fresh" || value === "bootstrap";
-}
 function validateExplicitValue(raw, name, isValid, validValues) {
     const value = raw?.trim();
     if (!value)
@@ -62,100 +27,27 @@ function validateExplicitValue(raw, name, isValid, validValues) {
         throw new Error(`Invalid ${name} "${value}". Use ${validValues}.`);
     return value;
 }
-export function isCursorCloudEnvironmentType(value) {
-    return value === "cloud" || value === "pool" || value === "machine";
-}
 function parseNonEmptyString(value) {
     if (typeof value !== "string")
         return undefined;
     const trimmed = value.trim();
     return trimmed ? trimmed : undefined;
 }
-function isAllowedEnvName(value) {
-    return typeof value === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) && !value.startsWith("CURSOR_");
-}
 function parseToolNames(value) {
     if (!Array.isArray(value))
         return undefined;
     const parsed = [...new Set(value.map((name) => (typeof name === "string" ? name.trim() : "")).filter((name) => name.length > 0))];
     return parsed.length > 0 ? parsed : undefined;
 }
-function parseEnvNames(value) {
-    const names = Array.isArray(value)
-        ? value
-        : typeof value === "string"
-            ? value.split(",")
-            : undefined;
-    if (!names)
-        return undefined;
-    const parsed = [...new Set(names.map((name) => (typeof name === "string" ? name.trim() : "")).filter(isAllowedEnvName))];
-    return parsed.length > 0 || (Array.isArray(value) && value.length === 0) ? parsed : undefined;
-}
-export function parseExplicitCursorCloudEnvNames(value, name) {
-    const request = parseNonEmptyString(value);
-    if (!request)
-        return undefined;
-    const parsed = parseEnvNames(request);
-    if (!parsed?.length)
-        throw new Error(`Invalid ${name}: no valid environment variable names were requested.`);
-    return parsed;
-}
-function parseCloudEnvironment(value) {
-    const environment = asRecord(value);
-    if (!environment)
-        return undefined;
-    const parsed = {};
-    const rawType = parseNonEmptyString(environment.type);
-    const name = parseNonEmptyString(environment.name);
-    if (rawType)
-        parsed.type = rawType;
-    if (name)
-        parsed.name = name;
-    return Object.keys(parsed).length > 0 ? parsed : undefined;
-}
 export function parseCursorSdkConfig(value) {
     const record = asRecord(value);
     if (!record)
         return undefined;
     const config = {};
-    if (isCursorRuntime(record.runtime))
-        config.runtime = record.runtime;
     const fastDefaults = asRecord(record.fastDefaults);
     if (fastDefaults) {
         config.fastDefaults = Object.fromEntries(Object.entries(fastDefaults).filter((entry) => typeof entry[1] === "boolean"));
     }
-    const cloud = asRecord(record.cloud);
-    if (cloud) {
-        const parsedCloud = {};
-        const repo = parseNonEmptyString(cloud.repo);
-        const branch = parseNonEmptyString(cloud.branch);
-        const envNames = parseEnvNames(cloud.envNames);
-        const environment = parseCloudEnvironment(cloud.environment);
-        if (repo)
-            parsedCloud.repo = repo;
-        if (branch)
-            parsedCloud.branch = branch;
-        if (isCursorCloudContextHandoff(cloud.contextHandoff))
-            parsedCloud.contextHandoff = cloud.contextHandoff;
-        if (typeof cloud.directPush === "boolean")
-            parsedCloud.directPush = cloud.directPush;
-        if (typeof cloud.autoCreatePR === "boolean")
-            parsedCloud.autoCreatePR = cloud.autoCreatePR;
-        if (typeof cloud.skipReviewerRequest === "boolean")
-            parsedCloud.skipReviewerRequest = cloud.skipReviewerRequest;
-        if (typeof cloud.allowLocalState === "boolean")
-            parsedCloud.allowLocalState = cloud.allowLocalState;
-        if (envNames)
-            parsedCloud.envNames = envNames;
-        if (typeof cloud.envFromFiles === "boolean")
-            parsedCloud.envFromFiles = cloud.envFromFiles;
-        if (environment)
-            parsedCloud.environment = environment;
-        if (typeof cloud.acknowledged === "boolean")
-            parsedCloud.acknowledged = cloud.acknowledged;
-        if (Object.keys(parsedCloud).length > 0)
-            config.cloud = parsedCloud;
-    }
     const local = asRecord(record.local);
     if (local) {
         const parsedLocal = {};
@@ -321,15 +213,11 @@ export function mergeCursorSdkConfig(base, patch) {
     return mergeCursorSdkConfigForUpdate({ ...base }, patch);
 }
 export function mergeCursorSdkConfigForUpdate(base, patch) {
-    const baseCloud = asRecord(base.cloud);
     const baseLocal = asRecord(base.local);
     const baseSandboxOptions = asRecord(baseLocal?.sandboxOptions);
     return {
         ...base,
         ...patch,
-        ...(baseCloud || patch.cloud
-            ? { cloud: { ...baseCloud, ...patch.cloud } }
-            : {}),
         ...(baseLocal || patch.local
             ? {
                 local: {
@@ -352,8 +240,8 @@ export function withCursorFastDefaults(config, fastDefaults) {
         fastDefaults: Object.fromEntries([...fastDefaults.entries()].sort(([a], [b]) => a.localeCompare(b))),
     };
 }
-function resolved(source, value, cappedBy) {
-    return { value, source, trustLevel: TRUST_LEVELS[source], ...(cappedBy ? { cappedBy } : {}) };
+function resolved(source, value) {
+    return { value, source, trustLevel: TRUST_LEVELS[source] };
 }
 function valueFrom(source, value) {
     return value === undefined ? undefined : resolved(source, value);
@@ -364,40 +252,6 @@ function resolveOrdinary(layers) {
         throw new Error("Cursor config resolver missing built-in default");
     return match;
 }
-// One cap engine for every safety-capped field. `cap` receives the candidate cap layer's raw value and the
-// resolved base setting; it returns the value to use once capped, or undefined to mean "don't cap". CLI is
-// always uncapped (one-shot, explicit operator intent).
-function resolveWithCap(baseLayers, capLayer, cap) {
-    const cli = baseLayers[0];
-    if (cli)
-        return cli;
-    const base = resolveOrdinary(baseLayers.slice(1));
-    if (!capLayer)
-        return base;
-    const cappedValue = cap(capLayer.value, base);
-    if (cappedValue === undefined)
-        return base;
-    return resolved(capLayer.source, cappedValue, {
-        source: capLayer.source,
-        trustLevel: capLayer.trustLevel,
-        value: cappedValue,
-        cappedSource: base.source,
-        cappedValue: base.value,
-        reason: "safer-source",
-    });
-}
-function scalarRiskCap(risk) {
-    return (candidate, base) => (risk(candidate) < risk(base.value) ? candidate : undefined);
-}
-function envNamesCap(candidate, base) {
-    if (base.source === "user")
-        return undefined;
-    const allowed = new Set(candidate);
-    const filtered = base.value.filter((name) => allowed.has(name));
-    return filtered.length === base.value.length ? undefined : filtered;
-}
-const RUNTIME_ORDER = ["cli", "environment", "session", "project", "user", "builtin"];
-const CLOUD_ORDER = ["cli", "environment", "session", "user", "builtin"];
 const LOCAL_ORDER = ["cli", "environment", "project", "user", "builtin"];
 const LOCAL_FORCE_ORDER = ["cli", "environment", "builtin"];
 const HTTP1_ORDER = ["session", "environment", "user", "builtin"];
@@ -408,56 +262,8 @@ function buildFieldLayers(order, values) {
 function resolveOrdinaryField(order, values) {
     return resolveOrdinary(buildFieldLayers(order, values));
 }
-function resolveSafetyField(order, values, risk) {
-    return resolveWithCap(buildFieldLayers(order, values), valueFrom("user", values.user), scalarRiskCap(risk));
-}
-function resolveEnvNamesSafetyField(order, values) {
-    return resolveWithCap(buildFieldLayers(order, values), valueFrom("user", values.user), envNamesCap);
-}
 export function cursorSdkConfigFromEnv(env = process.env) {
     const config = {};
-    const runtime = validateExplicitValue(env[CURSOR_RUNTIME_ENV], CURSOR_RUNTIME_ENV, isCursorRuntime, '"local" or "cloud"');
-    if (runtime)
-        config.runtime = runtime;
-    const repo = parseNonEmptyString(env[CURSOR_CLOUD_REPO_ENV]);
-    const branch = parseNonEmptyString(env[CURSOR_CLOUD_BRANCH_ENV]);
-    const contextHandoff = validateExplicitValue(env[CURSOR_CLOUD_CONTEXT_ENV], CURSOR_CLOUD_CONTEXT_ENV, isCursorCloudContextHandoff, '"never", "fresh", or "bootstrap"');
-    const directPush = parseOptionalEnvBoolean(env[CURSOR_CLOUD_DIRECT_PUSH_ENV]);
-    const autoCreatePR = parseOptionalEnvBoolean(env[CURSOR_CLOUD_AUTO_CREATE_PR_ENV]);
-    const skipReviewerRequest = parseOptionalEnvBoolean(env[CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV]);
-    const allowLocalState = parseOptionalEnvBoolean(env[CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV]);
-    const envNames = parseExplicitCursorCloudEnvNames(env[CURSOR_CLOUD_ENV_ENV], CURSOR_CLOUD_ENV_ENV);
-    const envFromFiles = parseOptionalEnvBoolean(env[CURSOR_CLOUD_ENV_FROM_FILES_ENV]);
-    const environment = parseCloudEnvironment({
-        type: env[CURSOR_CLOUD_ENV_TYPE_ENV],
-        name: env[CURSOR_CLOUD_ENV_NAME_ENV],
-    });
-    const acknowledged = parseOptionalEnvBoolean(env[CURSOR_CLOUD_ACK_ENV]);
-    if (repo !== undefined ||
-        branch !== undefined ||
-        isCursorCloudContextHandoff(contextHandoff) ||
-        directPush !== undefined ||
-        autoCreatePR !== undefined ||
-        skipReviewerRequest !== undefined ||
-        allowLocalState !== undefined ||
-        envNames !== undefined ||
-        envFromFiles !== undefined ||
-        environment !== undefined ||
-        acknowledged !== undefined) {
-        config.cloud = {
-            ...(repo !== undefined ? { repo } : {}),
-            ...(branch !== undefined ? { branch } : {}),
-            ...(isCursorCloudContextHandoff(contextHandoff) ? { contextHandoff } : {}),
-            ...(directPush !== undefined ? { directPush } : {}),
-            ...(autoCreatePR !== undefined ? { autoCreatePR } : {}),
-            ...(skipReviewerRequest !== undefined ? { skipReviewerRequest } : {}),
-            ...(allowLocalState !== undefined ? { allowLocalState } : {}),
-            ...(envNames !== undefined ? { envNames } : {}),
-            ...(envFromFiles !== undefined ? { envFromFiles } : {}),
-            ...(environment !== undefined ? { environment } : {}),
-            ...(acknowledged !== undefined ? { acknowledged } : {}),
-        };
-    }
     const autoReview = parseOptionalEnvBoolean(env[CURSOR_AUTO_REVIEW_ENV]);
     const sandbox = parseOptionalEnvBoolean(env[CURSOR_SANDBOX_ENV]);
     const force = parseOptionalEnvBoolean(env[CURSOR_LOCAL_FORCE_ENV]);
@@ -475,106 +281,12 @@ export function cursorSdkConfigFromEnv(env = process.env) {
     return config;
 }
 export function resolveCursorSdkConfig(options = {}) {
-    const cliRuntime = validateExplicitValue(options.cli?.runtime, "--cursor-runtime", isCursorRuntime, '"local" or "cloud"');
-    const cliContextHandoff = validateExplicitValue(options.cli?.cloud?.contextHandoff, "--cursor-cloud-context", isCursorCloudContextHandoff, '"never", "fresh", or "bootstrap"');
     const env = cursorSdkConfigFromEnv(options.env);
-    const builtIn = {
-        ...BUILT_IN_CURSOR_CONFIG,
-        ...options.builtIn,
-        cloud: { ...BUILT_IN_CURSOR_CONFIG.cloud, ...options.builtIn?.cloud },
-    };
     const cli = options.cli;
     const session = options.session;
     const project = options.project;
     const user = options.user;
     return {
-        runtime: resolveSafetyField(RUNTIME_ORDER, {
-            cli: cliRuntime,
-            environment: env.runtime,
-            session: session?.runtime,
-            project: project?.runtime,
-            user: user?.runtime,
-            builtin: builtIn.runtime,
-        }, (value) => (value === "cloud" ? 1 : 0)),
-        cloud: {
-            repo: resolveOrdinaryField(CLOUD_ORDER, {
-                cli: cli?.cloud?.repo,
-                environment: env.cloud?.repo,
-                session: session?.cloud?.repo,
-                user: user?.cloud?.repo,
-                builtin: undefined,
-            }),
-            branch: resolveOrdinaryField(CLOUD_ORDER, {
-                cli: cli?.cloud?.branch,
-                environment: env.cloud?.branch,
-                session: session?.cloud?.branch,
-                user: user?.cloud?.branch,
-                builtin: undefined,
-            }),
-            contextHandoff: resolveSafetyField(CLOUD_ORDER, {
-                cli: cliContextHandoff,
-                environment: env.cloud?.contextHandoff,
-                session: session?.cloud?.contextHandoff,
-                user: user?.cloud?.contextHandoff,
-                builtin: builtIn.cloud.contextHandoff,
-            }, (value) => ({ never: 0, fresh: 1, bootstrap: 2 })[value]),
-            directPush: resolveSafetyField(CLOUD_ORDER, {
-                cli: cli?.cloud?.directPush,
-                environment: env.cloud?.directPush,
-                session: session?.cloud?.directPush,
-                user: user?.cloud?.directPush,
-                builtin: builtIn.cloud.directPush,
-            }, (value) => (value ? 1 : 0)),
-            autoCreatePR: resolveSafetyField(CLOUD_ORDER, {
-                cli: cli?.cloud?.autoCreatePR,
-                environment: env.cloud?.autoCreatePR,
-                session: session?.cloud?.autoCreatePR,
-                user: user?.cloud?.autoCreatePR,
-                builtin: builtIn.cloud.autoCreatePR,
-            }, (value) => (value ? 1 : 0)),
-            skipReviewerRequest: resolveSafetyField(CLOUD_ORDER, {
-                cli: cli?.cloud?.skipReviewerRequest,
-                environment: env.cloud?.skipReviewerRequest,
-                session: session?.cloud?.skipReviewerRequest,
-                user: user?.cloud?.skipReviewerRequest,
-                builtin: builtIn.cloud.skipReviewerRequest,
-            }, (value) => (value ? 1 : 0)),
-            allowLocalState: resolveSafetyField(CLOUD_ORDER, {
-                cli: cli?.cloud?.allowLocalState,
-                environment: env.cloud?.allowLocalState,
-                session: session?.cloud?.allowLocalState,
-                user: user?.cloud?.allowLocalState,
-                builtin: builtIn.cloud.allowLocalState,
-            }, (value) => (value ? 1 : 0)),
-            envNames: resolveEnvNamesSafetyField(CLOUD_ORDER, {
-                cli: cli?.cloud?.envNames,
-                environment: env.cloud?.envNames,
-                session: session?.cloud?.envNames,
-                user: user?.cloud?.envNames,
-                builtin: builtIn.cloud.envNames,
-            }),
-            envFromFiles: resolveSafetyField(CLOUD_ORDER, {
-                cli: cli?.cloud?.envFromFiles,
-                environment: env.cloud?.envFromFiles,
-                session: session?.cloud?.envFromFiles,
-                user: user?.cloud?.envFromFiles,
-                builtin: builtIn.cloud.envFromFiles,
-            }, (value) => (value ? 1 : 0)),
-            environment: resolveOrdinaryField(CLOUD_ORDER, {
-                cli: cli?.cloud?.environment,
-                environment: env.cloud?.environment,
-                session: session?.cloud?.environment,
-                user: user?.cloud?.environment,
-                builtin: undefined,
-            }),
-            acknowledged: resolveOrdinaryField(CLOUD_ORDER, {
-                cli: cli?.cloud?.acknowledged,
-                environment: env.cloud?.acknowledged,
-                session: session?.cloud?.acknowledged,
-                user: user?.cloud?.acknowledged,
-                builtin: builtIn.cloud.acknowledged,
-            }),
-        },
         local: {
             autoReview: resolveOrdinaryField(LOCAL_ORDER, {
                 cli: cli?.local?.autoReview,

package/dist/cursor-provider-errors.js

@@ -3,7 +3,6 @@ import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 export const MISSING_CURSOR_API_KEY_MESSAGE = "Cursor SDK runs require a Cursor SDK API key. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, set CURSOR_API_KEY before starting pi, or restart pi with --api-key.";
 const GENERIC_CURSOR_SDK_ERROR_MESSAGE = "Cursor SDK request failed. The Cursor SDK API key may be missing, invalid, or unauthorized. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
 const AUTH_CURSOR_SDK_ERROR_MESSAGE = "Cursor SDK request failed because the Cursor SDK API key may be invalid or unauthorized. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
-const CLOUD_AUTH_CURSOR_SDK_ERROR_MESSAGE = "Cursor Cloud Agents request failed because Cloud API authentication rejected the API key. Use a user API key from Cursor Dashboard -> API Keys or a service account API key from Team settings; Team Admin API keys are not supported as Cursor Cloud Agents credentials. Configure the key with /login -> Use an API key -> Cursor, CURSOR_API_KEY, or --api-key, then retry.";
 // Keep "Network error" aligned with pi's agent-level retry classifier.
 const NETWORK_CURSOR_SDK_ERROR_MESSAGE = "Network error: Cursor SDK request failed during network or service I/O. Check your connection; pi will retry automatically when auto-retry is enabled.";
 // Keep this phrase aligned with pi's agent-level retry classifier (`provider.?returned.?error`).
@@ -29,53 +28,6 @@ function getErrorStringField(record, key) {
 function getErrorName(error, record) {
     return error instanceof Error ? error.name : getErrorStringField(record, "name");
 }
-function scrubHttpsHelpUrl(helpUrl, apiKey) {
-    if (!helpUrl)
-        return undefined;
-    try {
-        const url = new URL(helpUrl);
-        if (url.protocol !== "https:")
-            return undefined;
-        url.username = "";
-        url.password = "";
-        url.pathname = url.pathname
-            .split("/")
-            .map((segment) => {
-            const decoded = decodeURIComponent(segment);
-            const scrubbed = scrubSensitiveText(decoded, apiKey);
-            return scrubbed === decoded ? segment : encodeURIComponent(scrubbed);
-        })
-            .join("/");
-        const scrubbedParams = new URLSearchParams();
-        for (const [name, value] of url.searchParams) {
-            const scrubbedName = scrubSensitiveText(name, apiKey);
-            const scrubbedPair = scrubSensitiveText(`${name}=${value}`, apiKey);
-            scrubbedParams.append(scrubbedName, scrubbedPair === `${name}=${value}` ? value : "[redacted]");
-        }
-        url.search = scrubbedParams.toString();
-        if (url.hash) {
-            const decoded = decodeURIComponent(url.hash.slice(1));
-            const scrubbed = scrubSensitiveText(decoded, apiKey);
-            if (scrubbed !== decoded)
-                url.hash = encodeURIComponent(scrubbed);
-        }
-        return scrubSensitiveText(url.href, apiKey).trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function formatIntegrationNotConnectedError(error, record, scrubbedMessage, apiKey) {
-    if (getErrorName(error, record) !== "IntegrationNotConnectedError")
-        return undefined;
-    const provider = scrubSensitiveText(getErrorStringField(record, "provider") ?? "", apiKey).trim();
-    if (!provider)
-        return undefined;
-    const message = scrubbedMessage || "Cursor Cloud integration is not connected.";
-    const punctuation = /[.!?]$/.test(message) ? "" : ".";
-    const helpUrl = scrubHttpsHelpUrl(getErrorStringField(record, "helpUrl"), apiKey);
-    return `${message}${punctuation} Connect the ${provider} integration${helpUrl ? `: ${helpUrl}` : "."}`;
-}
 function getErrorStack(error, record) {
     return error instanceof Error ? error.stack ?? "" : getErrorStringField(record, "stack") ?? "";
 }
@@ -284,22 +236,15 @@ export function resolveCursorSdkAbortCause(options) {
         return "live_run_disposed";
     return "unknown";
 }
-export function sanitizeCursorProviderError(error, apiKey, runtimeTarget) {
+export function sanitizeCursorProviderError(error, apiKey) {
     const record = asRecord(error);
     const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
     if (message === MISSING_CURSOR_API_KEY_MESSAGE)
         return MISSING_CURSOR_API_KEY_MESSAGE;
     const scrubbed = scrubSensitiveText(message, apiKey).trim();
-    const integrationMessage = runtimeTarget === "cloud"
-        ? formatIntegrationNotConnectedError(error, record, scrubbed, apiKey)
-        : undefined;
-    if (integrationMessage)
-        return integrationMessage;
     const connectClassification = classifyCursorConnectError(error);
-    if ((runtimeTarget === "cloud" && getErrorName(error, record) === "AuthenticationError") ||
-        connectClassification?.kind === "unauthenticated" ||
-        isLikelyAuthError(scrubbed)) {
-        return runtimeTarget === "cloud" ? CLOUD_AUTH_CURSOR_SDK_ERROR_MESSAGE : AUTH_CURSOR_SDK_ERROR_MESSAGE;
+    if (connectClassification?.kind === "unauthenticated" || isLikelyAuthError(scrubbed)) {
+        return AUTH_CURSOR_SDK_ERROR_MESSAGE;
     }
     if (connectClassification?.kind === "network" || isCursorSdkConnectionStalledError(error) || isLikelyNetworkTimeout(scrubbed))
         return NETWORK_CURSOR_SDK_ERROR_MESSAGE;

package/dist/cursor-provider-live-run-drain.js

@@ -141,7 +141,6 @@ function emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolR
         }
     }
     applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
-        runtime: "local",
         turn: cursorLiveRuns.takeSdkTurnUsage(run),
     });
     partial.stopReason = "toolUse";
@@ -177,7 +176,6 @@ function emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolR
             stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial });
     }
     applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
-        runtime: "local",
         turn: cursorLiveRuns.takeSdkTurnUsage(run),
     });
     partial.stopReason = "toolUse";
@@ -293,7 +291,6 @@ export async function drainCursorLiveRunTurn(stream, partial, model, context, ru
                     await emitTextDeltas(stream, partial, splitTextIntoReplayDeltas(finalText));
                 }
                 applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
-                    runtime: "local",
                     turn: cursorLiveRuns.takeSdkTurnUsage(run),
                     billed: run.billedTurnUsage,
                 });

package/dist/cursor-provider-run-finalizer.js

@@ -58,7 +58,7 @@ export class CursorRunFinalizer {
             .catch((error) => {
             this.safeCleanup(() => discardIncompleteTools({ status: "error" }));
             if (!liveRun.disposed) {
-                cursorLiveRuns.markError(liveRun, sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey, "local"));
+                cursorLiveRuns.markError(liveRun, sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey));
             }
             this.safeCleanup(() => sdkEventDebug?.recordWaitResult({ status: "error", error: String(error) }));
             this.safeCleanup(() => sdkEventDebug?.recordError("run_wait", error));
@@ -72,7 +72,7 @@ export class CursorRunFinalizer {
         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;
         }
@@ -99,7 +99,7 @@ export class CursorRunFinalizer {
         await this.finalizeSdkEventDebugBestEffort();
         this.safeCleanup(() => this.params.sdkProcessErrorGuard.dispose());
     }
-    async applyDirectOutcome(prepared, outcome, displayOnlyTraceBlock) {
+    async applyDirectOutcome(prepared, outcome) {
         const { stream, partial, model, context } = this.params.runnerParams;
         prepared.runtime.turnCoordinator.closeTraceBlock();
         switch (classifyCursorRunEmission(outcome)) {
@@ -115,14 +115,11 @@ export class CursorRunFinalizer {
                 prepared.lifecycle.commitSend(context, prepared.meta.bootstrap);
                 prepared.runtime.turnCoordinator.flushText(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;
         }
@@ -145,7 +142,7 @@ export class CursorRunFinalizer {
             this.pushTerminalError(this.params.runnerParams.partial, "aborted", this.abortMessage());
         }
         else {
-            this.pushTerminalError(this.params.runnerParams.partial, "error", sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? this.params.runnerParams.options?.apiKey, prepared?.runtimeTarget ?? this.params.runtimeTarget()));
+            this.pushTerminalError(this.params.runnerParams.partial, "error", sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? this.params.runnerParams.options?.apiKey));
         }
     }
     pushTerminalError(partial, reason, message) {

package/dist/cursor-provider-run-outcome.js

@@ -42,7 +42,7 @@ export function resolveCursorRunOutcome(params) {
                 status: "error",
                 assistantTextProduced: false,
             }),
-            errorMessage: sanitizeCursorProviderError(failureDetail, params.resolvedApiKey ?? params.optionsApiKey, params.runtimeTarget),
+            errorMessage: sanitizeCursorProviderError(failureDetail, params.resolvedApiKey ?? params.optionsApiKey),
         };
     }
     const assistantTextProduced = hasCursorAssistantText(waitResult.result, params.textDeltas, params.planTextCandidate);

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 };
 }