pi-cursor-sdk 0.4.0 → 0.5.2

package/dist/cursor-provider-binding.js

@@ -0,0 +1,118 @@
+import { cursorApiKeyAuth, normalizeCursorApiKey, resolveCursorCredentialApiKey } from "./cursor-api-key.js";
+import { discoverModels } from "./model-discovery.js";
+import { clearModelListCache } from "./model-list-cache.js";
+import { captureCursorCloudLifecycleRecorder } from "./cursor-cloud-lifecycle.js";
+import { captureCursorUsageRecorder } from "./cursor-usage-ledger.js";
+import { getCursorNativeToolDisplayState } from "./cursor-native-tool-display-state.js";
+import { getRegisteredCursorPiToolBridge } from "./cursor-pi-tool-bridge.js";
+import { createCursorLazyStream } from "./cursor-provider-lazy.js";
+import { getCursorSessionScopeSnapshot } from "./cursor-session-scope.js";
+import { captureCursorRequestProjection, resolveCursorRequestProvenance } from "./cursor-request-provenance.js";
+export const CURSOR_PROVIDER_OWNERSHIP_ERROR = "Cursor provider ownership is unavailable: this request does not belong to the active Cursor registration. Reload this session's extensions to restore its Cursor registration; use independent ModelRuntime instances for sibling sessions.";
+const requestOwners = new WeakMap();
+/** One closure per ExtensionAPI, including direct compaction/tree/bug-report streams. */
+export function registerCursorProviderBinding(pi) {
+    const binding = { active: false, closed: false };
+    let registry;
+    const operations = new WeakMap();
+    pi.on("session_before_compact", (event) => { operations.set(event.signal, "compaction"); });
+    pi.on("session_before_tree", (event) => { operations.set(event.signal, "tree"); });
+    pi.on("before_provider_headers", (event, ctx) => {
+        const notices = new Set();
+        // Pi's SDK supplies this session-owned callback for ordinary and auxiliary
+        // streams. ModelRuntime forwards the same real headers object to the provider.
+        requestOwners.set(event.headers, {
+            binding,
+            scope: getCursorSessionScopeSnapshot(pi),
+            projection: captureCursorRequestProjection(ctx.sessionManager),
+            usageRecorder: captureCursorUsageRecorder(pi, ctx),
+            reportSdkNotice: (kind, message) => {
+                if (!binding.active || binding.closed)
+                    return false;
+                if (notices.has(kind))
+                    return;
+                pi.appendEntry("pi-cursor-sdk:capability-notice", { kind, message });
+                if (ctx.hasUI)
+                    ctx.ui.notify(message, "warning");
+                else
+                    console.warn(message);
+                notices.add(kind);
+            },
+        });
+    });
+    const stream = createCursorLazyStream((model, context, options) => {
+        const headers = options?.headers;
+        const owner = headers && requestOwners.get(headers);
+        if (headers)
+            requestOwners.delete(headers);
+        if (!binding.active || binding.closed)
+            throw new Error("Cursor provider binding is not active. Bind this session's extensions, or reload the session after shutdown.");
+        if (!owner)
+            throw new Error("Cursor provider ownership is unavailable: this call has no native session request receipt. Bare modelRegistry.streamSimple calls are unsupported for Cursor; use the owning AgentSession's stream path or an independent child AgentSession.");
+        if (owner.binding !== binding)
+            throw new Error(CURSOR_PROVIDER_OWNERSHIP_ERROR);
+        return {
+            request: resolveCursorRequestProvenance(owner.projection, model, context, options?.signal && operations.get(options.signal) || "normal"),
+            usageRecorder: owner.usageRecorder,
+            scope: owner.scope,
+            bridge: getRegisteredCursorPiToolBridge(pi),
+            nativeDisplay: getCursorNativeToolDisplayState(pi),
+            recordCloudLifecycle: captureCursorCloudLifecycleRecorder(pi),
+            reportSdkNotice: owner.reportSdkNotice,
+        };
+    });
+    pi.on("session_start", async (_event, ctx) => {
+        if (binding.closed)
+            return;
+        binding.active = true;
+        registry = ctx.modelRegistry;
+        // The genuine extension context supplies composed config auth; startup
+        // selection already has the known baseline, without reading a default store.
+        await registry.refresh({ providers: ["cursor"], allowNetwork: false });
+    });
+    pi.on("session_shutdown", () => { binding.active = false; binding.closed = true; registry = undefined; });
+    return (models, onCatalog) => {
+        if (binding.closed)
+            return;
+        const toNative = (definitions) => definitions.map(({ compat: _compat, ...definition }) => ({
+            ...definition, provider: "cursor", api: "cursor-sdk", baseUrl: "https://cursor.com",
+        }));
+        let current = toNative(models);
+        const provider = {
+            id: "cursor", name: "Cursor", baseUrl: "https://cursor.com",
+            auth: { apiKey: cursorApiKeyAuth() },
+            getModels: () => current,
+            stream: stream,
+            streamSimple: stream,
+            async refreshModels(context) {
+                if (binding.closed)
+                    return;
+                const resolved = await registry?.getProviderAuth("cursor");
+                context.signal.throwIfAborted();
+                const credential = context.credential;
+                const apiKey = registry
+                    ? normalizeCursorApiKey(resolved?.auth.apiKey)
+                    : credential && credential.type !== "api_key" ? undefined
+                        : await resolveCursorCredentialApiKey(credential, async () => process.env.CURSOR_API_KEY);
+                let issue;
+                await discoverModels({
+                    apiKey, allowNetwork: context.allowNetwork, forceRefresh: context.force, signal: context.signal,
+                    onFallback: (next) => { issue = next; },
+                    publish: (definitions, update) => context.publish({
+                        update: () => {
+                            if (binding.closed)
+                                return;
+                            update();
+                            current = toNative(definitions);
+                            // Do not infer logout before native composed auth is reachable.
+                            if (registry && !apiKey)
+                                clearModelListCache();
+                            onCatalog(issue);
+                        },
+                    }),
+                });
+            },
+        };
+        pi.registerProvider(provider);
+    };
+}

package/dist/cursor-provider-errors.js

@@ -1,11 +1,11 @@
 import { asRecord } from "./cursor-record-utils.js";
 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 GENERIC_CURSOR_SDK_ERROR_MESSAGE = "Cursor SDK request failed without further error details.";
 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.";
+const NETWORK_CURSOR_SDK_ERROR_MESSAGE = "Network error: Cursor SDK request failed during network or service I/O. Check your connection.";
 // Keep this phrase aligned with pi's agent-level retry classifier (`provider.?returned.?error`).
 const RETRYABLE_CURSOR_RUN_FAILURE_PREFIX = "Provider returned error: Cursor SDK run failed";
 function isGenericErrorMessage(message) {
@@ -120,7 +120,11 @@ function collectConnectErrorStacks(error, record) {
 }
 function isConnectError(error, record) {
     const name = error instanceof Error ? error.name : getErrorStringField(record, "name");
-    return name === "ConnectError";
+    if (name === "ConnectError")
+        return true;
+    // @cursor/sdk convertConnectError re-wraps backend ConnectErrors (name -> NetworkError,
+    // code -> "unavailable") and leaves the original ConnectError on `.cause` without outer details.
+    return getErrorStringField(asRecord(record?.cause), "name") === "ConnectError";
 }
 function isUnauthenticatedConnectCode(code) {
     return code === 16 || (typeof code === "string" && /^(?:16|unauthenticated)$/i.test(code));
@@ -133,11 +137,10 @@ function isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence) {
         /(?:operation was aborted|canceled)/i.test(evidence) &&
         /(?:AbortError|operation was aborted)/i.test(`${evidence}\n${stackEvidence}`) &&
         stackEvidence.includes("@cursor/sdk") &&
-        stackEvidence.includes("@connectrpc/connect-node") &&
         /\b(?:onStall|reportStall|StallDetected)\b/i.test(stackEvidence));
 }
 /**
- * @cursor/sdk@1.0.32 throws internal RetriableError (name/kind "RetriableError") with message
+ * @cursor/sdk@1.0.36 throws internal RetriableError (name/kind "RetriableError") with message
  * "Connection stalled" or "Connection stalled repeatedly" after fetchWithRetry exhausts stalls.
  * The ConnectError is only the cause; the top-level error is not a ConnectError.
  */
@@ -154,25 +157,23 @@ export function isCursorSdkConnectionStalledError(error) {
     const stack = getErrorStack(error, record);
     return /(?:^|[\\/])node_modules[\\/]@cursor[\\/]sdk[\\/]dist[\\/]/.test(stack) || stack.includes("@cursor/sdk");
 }
-function isCursorExtensionConnectStack(stack) {
-    // pi runs Cursor SDK in Node, where the SDK dynamically imports connect-node.
-    // connect-web is the SDK's Bun/Deno path and is intentionally not classified for supported pi runs.
-    return stack.includes("@connectrpc/connect-node") && /(?:^|[\\/])pi-cursor-sdk(?:[\\/]|$)/.test(stack);
-}
 function getCursorConnectSource(error, record) {
-    const stack = getErrorStack(error, record);
+    const stack = collectConnectErrorStacks(error, record);
+    // Node/Bun use the SDK's vendored transport; Deno uses connect-web.
     if (stack.includes("@cursor/sdk"))
         return "cursor-sdk-stack";
-    if (isCursorExtensionConnectStack(stack))
-        return "cursor-extension-connect-stack";
-    const details = Array.isArray(record?.details) ? record.details : [];
-    const hasCursorBackendDetails = details.some((detail) => {
-        const type = getErrorStringField(asRecord(detail), "type");
-        return typeof type === "string" && type.startsWith("aiserver.");
-    });
-    if (hasCursorBackendDetails)
-        return "cursor-backend-details";
-    return stack.includes("@connectrpc/connect-node") ? "connect-node-stack" : "generic-connect";
+    let current = record;
+    for (let depth = 0; depth < 3 && current; depth += 1) {
+        const details = Array.isArray(current.details) ? current.details : [];
+        const hasCursorBackendDetails = details.some((detail) => {
+            const type = getErrorStringField(asRecord(detail), "type");
+            return typeof type === "string" && type.startsWith("aiserver.");
+        });
+        if (hasCursorBackendDetails)
+            return "cursor-backend-details";
+        current = asRecord(current.cause);
+    }
+    return "generic-connect";
 }
 export function classifyCursorConnectError(error) {
     const record = asRecord(error);
@@ -186,16 +187,22 @@ export function classifyCursorConnectError(error) {
     const stack = getErrorStack(error, record);
     const evidence = collectConnectErrorEvidence(error, record);
     const stackEvidence = collectConnectErrorStacks(error, record);
-    if ((code === 1 || code === "canceled") &&
-        Boolean(rawMessage && /(?:operation was aborted|canceled)/i.test(rawMessage)) &&
-        (causeName === "AbortError" || /AbortError/.test(stack)) &&
-        stack.includes("@cursor/sdk") &&
-        stack.includes("@connectrpc/connect-node")) {
-        return { kind: "abort", source: "cursor-sdk-stack" };
-    }
     if (isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence)) {
         return { kind: "network", source: getCursorConnectSource(error, record) };
     }
+    const directAbort = (code === 1 || code === "canceled") &&
+        (causeName === "AbortError" || /AbortError/.test(stack));
+    // The vendored 1.0.36 transport wraps a canceled ConnectError as Unknown.
+    // Require the observed canceled -> AbortError cause chain, not generic text.
+    const wrappedAbort = (code === 2 || code === "unknown") &&
+        causeName === "ConnectError" &&
+        (cause?.code === 1 || cause?.code === "canceled") &&
+        asRecord(cause?.cause)?.name === "AbortError";
+    if ((directAbort || wrappedAbort) &&
+        Boolean(rawMessage && /(?:operation was aborted|canceled)/i.test(rawMessage)) &&
+        stack.includes("@cursor/sdk")) {
+        return { kind: "abort", source: "cursor-sdk-stack" };
+    }
     if (isUnauthenticatedConnectCode(code) || isLikelyAuthError(evidence)) {
         return { kind: "unauthenticated", source: getCursorConnectSource(error, record) };
     }
@@ -284,23 +291,44 @@ export function resolveCursorSdkAbortCause(options) {
         return "live_run_disposed";
     return "unknown";
 }
+function formatErrorDetail(error, apiKey, depth = 0) {
+    if (depth >= 3)
+        return "";
+    const record = asRecord(error);
+    const message = typeof error === "string" ? error : getErrorStringField(record, "message") ?? "";
+    const name = getErrorStringField(record, "name");
+    const code = getErrorEvidenceField(error, record, "code");
+    const scrub = (text, limit) => scrubSensitiveText(text, apiKey).trim().slice(0, limit);
+    const scrubbed = [
+        name && name !== "Error" ? `${scrub(name, 120)}:` : "",
+        code ? `(code: ${scrub(code, 120)})` : "",
+        scrub(message, 1600),
+    ].filter(Boolean).join(" ");
+    const cause = record?.cause === undefined ? "" : formatErrorDetail(record.cause, apiKey, depth + 1);
+    return cause ? `${scrubbed}\nCaused by: ${cause}` : scrubbed;
+}
 export function sanitizeCursorProviderError(error, apiKey, runtimeTarget) {
     const record = asRecord(error);
-    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+    const message = typeof error === "string" ? error : getErrorStringField(record, "message") ?? "";
     if (message === MISSING_CURSOR_API_KEY_MESSAGE)
         return MISSING_CURSOR_API_KEY_MESSAGE;
-    const scrubbed = scrubSensitiveText(message, apiKey).trim();
+    const scrubbed = formatErrorDetail(error, apiKey);
+    // A loader failure is not an auth rejection, even inside an authentication wrapper.
+    if (/\b(?:ERR_MODULE_NOT_FOUND|MODULE_NOT_FOUND|ResolveMessage)\b|Cannot find (?:module|package)|does not provide an export named/i.test(scrubbed))
+        return scrubbed;
     const integrationMessage = runtimeTarget === "cloud"
-        ? formatIntegrationNotConnectedError(error, record, scrubbed, apiKey)
+        ? formatIntegrationNotConnectedError(error, record, scrubSensitiveText(message, apiKey).trim(), apiKey)
         : undefined;
     if (integrationMessage)
         return integrationMessage;
     const connectClassification = classifyCursorConnectError(error);
     if ((runtimeTarget === "cloud" && getErrorName(error, record) === "AuthenticationError") ||
-        connectClassification?.kind === "unauthenticated" ||
-        isLikelyAuthError(scrubbed)) {
+        /\b(?:invalid|revoked|expired|missing) (?:user )?api key\b|\bapi key (?:is )?(?:invalid|revoked|expired|missing)\b/i.test(scrubbed)) {
         return runtimeTarget === "cloud" ? CLOUD_AUTH_CURSOR_SDK_ERROR_MESSAGE : AUTH_CURSOR_SDK_ERROR_MESSAGE;
     }
+    if (connectClassification?.kind === "unauthenticated" || isLikelyAuthError(scrubbed)) {
+        return `Cursor SDK authentication failed. ${scrubbed}`;
+    }
     if (connectClassification?.kind === "network" || isCursorSdkConnectionStalledError(error) || isLikelyNetworkTimeout(scrubbed))
         return NETWORK_CURSOR_SDK_ERROR_MESSAGE;
     if (isGenericCursorRunFailureMessage(scrubbed))

package/dist/cursor-provider-lazy.js

@@ -21,19 +21,31 @@ function makeProviderRuntimeErrorMessage(model, error, apiKey) {
         errorMessage: `Cursor provider runtime failed: ${sanitizeCursorProviderError(error, apiKey)}`,
     };
 }
-export function streamCursorLazy(model, context, options) {
-    const outer = createAssistantMessageEventStream();
-    queueMicrotask(async () => {
-        try {
-            for await (const event of streamCursor(model, context, options)) {
-                outer.push(event);
-            }
-        }
-        catch (error) {
+export function createCursorLazyStream(capture) {
+    return (model, context, options) => {
+        const outer = createAssistantMessageEventStream();
+        const fail = (error) => {
             const message = makeProviderRuntimeErrorMessage(model, error, options?.apiKey);
             outer.push({ type: "error", reason: "error", error: message });
             outer.end(message);
+        };
+        let ownership;
+        try {
+            ownership = capture(model, context, options);
         }
-    });
-    return outer;
+        catch (error) {
+            fail(error);
+            return outer;
+        }
+        queueMicrotask(async () => {
+            try {
+                for await (const event of streamCursor(model, context, options, ownership))
+                    outer.push(event);
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+        return outer;
+    };
 }

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

@@ -10,8 +10,14 @@ import { formatCursorSdkAbortMessage, resolveCursorSdkAbortCause } from "./curso
 import { formatInactiveCursorReplayTrace } from "./cursor-native-replay-trace.js";
 import { partitionNativeToolsByActiveContext } from "./cursor-native-replay-routing.js";
 export const DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS = 5 * 60 * 1000;
+function parseCursorNativeReplayIdleDisposeMs(raw) {
+    if (!raw || /[^0-9]/.test(raw))
+        return DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+    const value = Number(raw);
+    return value >= 1 && value <= 2147483647 ? value : DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+}
 const CURSOR_NATIVE_REPLAY_TOOL_ID_PATTERN = /^(cursor-replay-\d+-\d+)-tool-\d+$/;
-let cursorNativeReplayIdleDisposeMs = DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+let cursorNativeReplayIdleDisposeMsOverride;
 let cursorNativeReplayCounter = 0;
 export async function abandonSessionCursorAgent(scopeKey) {
     if (!scopeKey)
@@ -19,7 +25,7 @@ export async function abandonSessionCursorAgent(scopeKey) {
     await resetSessionCursorAgent(scopeKey);
 }
 export const cursorLiveRuns = createCursorLiveRunCoordinator({
-    getIdleDisposeMs: () => cursorNativeReplayIdleDisposeMs,
+    getIdleDisposeMs: () => cursorNativeReplayIdleDisposeMsOverride ?? parseCursorNativeReplayIdleDisposeMs(process.env.PI_CURSOR_LIVE_RUN_IDLE_DISPOSE_MS),
     deleteNativeToolDisplay: deleteCursorNativeToolDisplay,
     abandonSessionAgent: (scopeKey) => abandonSessionCursorAgent(scopeKey),
 });
@@ -30,11 +36,11 @@ export function createCursorNativeReplayId() {
 function getCursorNativeReplayIdFromToolCallId(toolCallId) {
     return CURSOR_NATIVE_REPLAY_TOOL_ID_PATTERN.exec(toolCallId)?.[1];
 }
-export function getPendingCursorLiveRun(context) {
-    return cursorLiveRuns.getPendingFromContext(context, getCursorNativeReplayIdFromToolCallId);
+export function getPendingCursorLiveRun(context, scopeKey) {
+    return cursorLiveRuns.getPendingFromContext(context, getCursorNativeReplayIdFromToolCallId, scopeKey);
 }
-export function getActiveCursorLiveRunForCurrentScope() {
-    return cursorLiveRuns.getActiveForScope();
+export function getActiveCursorLiveRunForCurrentScope(scopeKey) {
+    return cursorLiveRuns.getActiveForScope(scopeKey);
 }
 function splitTextIntoReplayDeltas(text) {
     const deltas = [];
@@ -125,7 +131,7 @@ function emitCursorLiveQueuedEvent(turn, event, run) {
         turn.emitter.appendTextDelta(event.text);
     }
 }
-function emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, tools, debugRecorder) {
+function emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, tools, occupancyFloor, debugRecorder) {
     const shouldTerminate = run.done && !run.finalText?.trim() && !cursorLiveRuns.peekEvent(run);
     for (const tool of tools) {
         const contentIndex = partial.content.length;
@@ -142,7 +148,7 @@ function emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolR
         const block = partial.content[contentIndex];
         if (block.type === "toolCall")
             stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial });
-        if (recordCursorNativeToolDisplay({ ...tool, terminate: shouldTerminate })) {
+        if (recordCursorNativeToolDisplay({ ...tool, terminate: shouldTerminate }, run.nativeDisplay)) {
             run.recordedToolDisplayIds.push(tool.id);
             debugRecorder?.recordDrainEvent("native_tool_display_recorded", {
                 toolId: tool.id,
@@ -154,6 +160,7 @@ function emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolR
     applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
         runtime: "local",
         turn: cursorLiveRuns.takeSdkTurnUsage(run),
+        occupancyFloor,
     });
     partial.stopReason = "toolUse";
     stream.push({ type: "done", reason: "toolUse", message: partial });
@@ -172,7 +179,7 @@ function emitInactiveCursorReplayTrace(turn, tools, debugRecorder) {
         turn.emitter.appendThinkingBlock(traceText);
     }
 }
-function emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, requests) {
+function emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, requests, occupancyFloor) {
     for (const request of requests) {
         const contentIndex = partial.content.length;
         const serializedArgs = JSON.stringify(request.args);
@@ -191,6 +198,7 @@ function emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolR
     applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
         runtime: "local",
         turn: cursorLiveRuns.takeSdkTurnUsage(run),
+        occupancyFloor,
     });
     partial.stopReason = "toolUse";
     stream.push({ type: "done", reason: "toolUse", message: partial });
@@ -217,7 +225,7 @@ async function emitCursorLiveRunPendingToolUseTurn(turn, stream, partial, model,
             cursorLiveRuns.ignoreFutureSdkTurnUsage(run);
         if (options.mode === "emit")
             turn.emitter.closeAll();
-        emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, active, debugRecorder);
+        emitCursorNativeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, active, options.occupancyFloor, debugRecorder);
     }
     else {
         const requests = cursorLiveRuns.collectBridgeToolBatch(run);
@@ -227,7 +235,7 @@ async function emitCursorLiveRunPendingToolUseTurn(turn, stream, partial, model,
             cursorLiveRuns.ignoreFutureSdkTurnUsage(run);
         if (options.mode === "emit")
             turn.emitter.closeAll();
-        emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, requests);
+        emitCursorBridgeToolUseTurn(stream, partial, model, context, run, toolResultInputTokens, requests, options.occupancyFloor);
     }
     return "tool_use";
 }
@@ -307,7 +315,7 @@ export async function drainCursorLiveRunTurn(stream, partial, model, context, ru
                 applyCursorUsage(partial, model, context, cursorLiveRuns.takeTurnInputTokens(run, toolResultInputTokens), {
                     runtime: "local",
                     turn: cursorLiveRuns.takeSdkTurnUsage(run),
-                    billed: run.billedTurnUsage,
+                    occupancyFloor: options.occupancyFloor,
                 });
                 if (run.resumeNotice) {
                     emitDisplayOnlyTraceBlock(stream, partial, run.resumeNotice);
@@ -349,10 +357,10 @@ export async function drainCursorLiveRunTurn(stream, partial, model, context, ru
         });
     }
 }
-export async function drainExistingCursorLiveRunBeforeSend(stream, partial, model, context, signal, turnDebugRecorder) {
+export async function drainExistingCursorLiveRunBeforeSend(stream, partial, model, context, signal, turnDebugRecorder, scopeKey, occupancyFloor) {
     turnDebugRecorder?.recordDrainEvent("pre_send_start", {});
     while (true) {
-        const run = getPendingCursorLiveRun(context) ?? getActiveCursorLiveRunForCurrentScope();
+        const run = getPendingCursorLiveRun(context, scopeKey) ?? getActiveCursorLiveRunForCurrentScope(scopeKey);
         if (!run || run.disposed) {
             turnDebugRecorder?.recordDrainEvent("pre_send_end", { outcome: "continue_send", reason: "no_pending_run" });
             return "continue_send";
@@ -375,6 +383,7 @@ export async function drainExistingCursorLiveRunBeforeSend(stream, partial, mode
                     mode: shouldChainUserInput ? "chain_user_input" : "emit",
                     signal,
                     debugRecorder: turnDebugRecorder,
+                    occupancyFloor,
                 });
                 const mapped = drainOutcome === "chain_user_input" ? "continue_send" : "stream_ended";
                 turnDebugRecorder?.recordDrainEvent("pre_send_iteration", {
@@ -404,10 +413,10 @@ export async function drainExistingCursorLiveRunBeforeSend(stream, partial, mode
     }
 }
 export function setCursorNativeReplayIdleDisposeMs(value) {
-    cursorNativeReplayIdleDisposeMs = value;
+    cursorNativeReplayIdleDisposeMsOverride = value;
 }
 export function resetCursorNativeReplayIdleDisposeMs() {
-    cursorNativeReplayIdleDisposeMs = DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS;
+    cursorNativeReplayIdleDisposeMsOverride = undefined;
 }
 export async function releaseAllPendingCursorLiveRunsForTests() {
     while (cursorLiveRuns.count() > 0) {

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

@@ -3,7 +3,7 @@ import { classifyCursorRunEmission, getCursorRunAbortMessage, } from "./cursor-p
 import { formatCursorSdkAbortMessage, resolveCursorSdkAbortCause, sanitizeCursorProviderError, } from "./cursor-provider-errors.js";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import { buildIncompleteCursorToolRunOutcome, } from "./cursor-incomplete-tool-visibility.js";
-import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
+import { awaitFinalizeCursorRunOutcome, recordCursorProviderTerminalUsage } from "./cursor-provider-turn-finalize.js";
 import { applyCursorUsage } from "./cursor-usage-accounting.js";
 import { hasUsableText } from "./cursor-record-utils.js";
 import { emitDisplayOnlyTraceBlock } from "./cursor-display-only-trace.js";
@@ -56,11 +56,15 @@ export class CursorRunFinalizer {
             applyLiveRunOutcome(finalized.outcome, prepared, runnerParams.context);
         })
             .catch((error) => {
-            this.safeCleanup(() => discardIncompleteTools({ status: "error" }));
+            const aborted = error instanceof CursorLiveRunAbortError || runnerParams.options?.signal?.aborted === true;
+            this.safeCleanup(() => discardIncompleteTools({ status: aborted ? "cancelled" : "error" }));
             if (!liveRun.disposed) {
-                cursorLiveRuns.markError(liveRun, sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey, "local"));
+                if (aborted)
+                    cursorLiveRuns.markCancelled(liveRun, this.abortMessage());
+                else
+                    cursorLiveRuns.markError(liveRun, sanitizeCursorProviderError(error, this.params.resolvedApiKey() ?? runnerParams.options?.apiKey, "local"));
             }
-            this.safeCleanup(() => sdkEventDebug?.recordWaitResult({ status: "error", error: String(error) }));
+            this.safeCleanup(() => sdkEventDebug?.recordWaitResult({ status: aborted ? "cancelled" : "error", error: String(error) }));
             this.safeCleanup(() => sdkEventDebug?.recordError("run_wait", error));
         });
         // Mark the pooled local agent busy as soon as the SDK run exists so auto-compaction summarization
@@ -80,12 +84,12 @@ export class CursorRunFinalizer {
         this.terminalApplied = true;
     }
     async cleanup(prepared, sendResult, liveCompletion) {
-        this.safeCleanup(() => prepared?.restoreCursorSdkOutputFilter());
         const abortRegistration = sendResult?.abortRegistration;
         this.params.runnerParams.sdkEventDebugRef.current = undefined;
         if (liveCompletion) {
             void liveCompletion.waitCompletion
                 .finally(async () => {
+                this.safeCleanup(() => prepared?.restoreCursorSdkOutputFilter());
                 if (abortRegistration) {
                     this.safeCleanup(() => abortRegistration.signal.removeEventListener("abort", abortRegistration.listener));
                 }
@@ -95,6 +99,7 @@ export class CursorRunFinalizer {
                 .catch(() => { });
             return;
         }
+        this.safeCleanup(() => prepared?.restoreCursorSdkOutputFilter());
         if (abortRegistration) {
             this.safeCleanup(() => abortRegistration.signal.removeEventListener("abort", abortRegistration.listener));
         }
@@ -104,6 +109,9 @@ export class CursorRunFinalizer {
     }
     async applyDirectOutcome(prepared, outcome, displayOnlyTraceBlock) {
         const { stream, partial, model, context } = this.params.runnerParams;
+        // Native summaries return at terminal emission, so release their temporary resources first.
+        if (prepared.execution === "summary")
+            await prepared.lifecycle.dispose().catch(() => { });
         prepared.runtime.turnCoordinator.closeTraceBlock();
         switch (classifyCursorRunEmission(outcome)) {
             case "cancelled":
@@ -120,7 +128,7 @@ export class CursorRunFinalizer {
                 applyCursorUsage(partial, model, context, prepared.meta.promptInputTokens, {
                     runtime: prepared.runtimeTarget,
                     turn: prepared.runtime.turnCoordinator.lastSdkTurnUsage,
-                    billed: prepared.runtime.billedTurnUsage,
+                    occupancyFloor: this.params.runnerParams.request.occupancyFloor,
                 });
                 if (prepared.meta.resumeNotice)
                     emitDisplayOnlyTraceBlock(stream, partial, prepared.meta.resumeNotice);
@@ -131,9 +139,13 @@ export class CursorRunFinalizer {
         }
     }
     async applyErrorOutcome(prepared, error) {
+        const aborted = error instanceof CursorLiveRunAbortError || this.params.runnerParams.options?.signal?.aborted === true;
+        if (prepared && "usage" in prepared && (!prepared.runtime.sdkRun || prepared.runtime.kind !== "live")) {
+            await recordCursorProviderTerminalUsage(prepared, aborted ? "abort" : "error");
+        }
         this.safeCleanup(() => prepared?.runtime.turnCoordinator.discardIncompleteStartedToolCalls(buildIncompleteCursorToolRunOutcome({
-            status: error instanceof CursorLiveRunAbortError ? "cancelled" : "error",
-            signalAborted: error instanceof CursorLiveRunAbortError,
+            status: aborted ? "cancelled" : "error",
+            signalAborted: aborted,
         })));
         const activeLiveRun = prepared?.runtime.liveRun;
         if (activeLiveRun && !activeLiveRun.disposed) {
@@ -143,7 +155,7 @@ export class CursorRunFinalizer {
             await prepared?.lifecycle.abandon();
         }
         this.safeCleanup(() => this.params.sdkEventDebug()?.recordError("provider_stream", error));
-        if (error instanceof CursorLiveRunAbortError) {
+        if (aborted) {
             this.params.sdkProcessErrorGuard.suppressAbortErrors();
             this.pushTerminalError(this.params.runnerParams.partial, "aborted", this.abortMessage());
         }

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

@@ -49,6 +49,7 @@ export class CursorSdkTurnCoordinator {
             liveRun: options.liveRun,
             useNativeToolReplay: options.useNativeToolReplay,
             activeToolNames: options.activeToolNames,
+            registeredToolNames: options.registeredToolNames,
             nativeReplayId: options.nativeReplayId,
             contentEmitter: this.contentEmitter,
             debugRecorder: options.debugRecorder,

package/dist/cursor-provider-turn-display-router.js

@@ -15,6 +15,7 @@ export class CursorTurnDisplayRouter {
     liveRun;
     useNativeToolReplay;
     activeToolNames;
+    registeredToolNames;
     nativeReplayId;
     contentEmitter;
     debugRecorder;
@@ -27,6 +28,7 @@ export class CursorTurnDisplayRouter {
         this.liveRun = options.liveRun;
         this.useNativeToolReplay = options.useNativeToolReplay;
         this.activeToolNames = options.activeToolNames;
+        this.registeredToolNames = options.registeredToolNames;
         this.nativeReplayId = options.nativeReplayId;
         this.contentEmitter = options.contentEmitter;
         this.debugRecorder = options.debugRecorder;
@@ -41,6 +43,7 @@ export class CursorTurnDisplayRouter {
             toolName: display.toolName,
             useNativeToolReplay: this.useNativeToolReplay,
             activeToolNames: this.activeToolNames,
+            registeredToolNames: this.registeredToolNames,
             hasLiveRun: this.liveRun !== undefined,
         });
         if (disposition === "queue_replay" && this.liveRun) {
@@ -78,6 +81,7 @@ export class CursorTurnDisplayRouter {
             toolName: display.toolName,
             useNativeToolReplay: this.useNativeToolReplay,
             activeToolNames: this.activeToolNames,
+            registeredToolNames: this.registeredToolNames,
             hasLiveRun: this.liveRun !== undefined,
         });
         if (disposition === "queue_replay" && this.liveRun && reason !== "abort") {

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

@@ -21,6 +21,7 @@ export async function emitCursorLiveTurn(emitParams) {
                 emitter,
                 signal: options?.signal,
                 debugRecorder: sdkEventDebug,
+                occupancyFloor: params.request.occupancyFloor,
             });
         });
     }