pi-cursor-sdk 0.4.0 → 0.5.0

package/dist/cursor-native-tool-display-tools.js

@@ -1,6 +1,5 @@
 import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { getCursorSessionCwd } from "./cursor-session-scope.js";
 import { CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES, CURSOR_REPLAY_TOOL_NAMES, } from "./cursor-native-tool-names.js";
 import { isCursorReplayToolName } from "./cursor-tool-presentation-registry.js";
 import { createCursorReplayOnlyToolDefinition, isCursorReplayNativeEditDetails, isCursorReplayNativeWriteDetails, parseCursorReplayToolDetails, renderCursorReplayResult, renderNativeLookingCursorFileMutationCall, renderNativeLookingCursorReadReplayResult, } from "./cursor-native-tool-display-replay.js";
@@ -61,12 +60,12 @@ function getNativeReplayStrategy(toolName) {
         ? NATIVE_CURSOR_TOOL_STRATEGIES[toolName]
         : undefined;
 }
-export function wrapNativeCursorTool(definition, getCurrentDefinition) {
+export function wrapNativeCursorTool(definition, getCurrentDefinition, state) {
     const strategy = getNativeReplayStrategy(definition.name);
     return {
         ...definition,
         async execute(toolCallId, params, signal, onUpdate, ctx) {
-            const cursorDisplay = consumeCursorNativeToolDisplay(toolCallId);
+            const cursorDisplay = consumeCursorNativeToolDisplay(toolCallId, state, definition.name);
             if (cursorDisplay) {
                 if (cursorDisplay.isError) {
                     const text = cursorDisplay.result.content
@@ -114,8 +113,8 @@ export function createNativeCursorToolDefinition(toolName, cwd) {
         return createCursorReplayOnlyToolDefinition(toolName);
     throw new Error(`Unsupported Cursor native replay tool: ${toolName}`);
 }
-export function registerNativeCursorTool(pi, toolName) {
-    const definition = createNativeCursorToolDefinition(toolName, getCursorSessionCwd());
-    pi.registerTool(wrapNativeCursorTool(definition, () => createNativeCursorToolDefinition(toolName, getCursorSessionCwd())));
+export function registerNativeCursorTool(pi, toolName, getCwd, state) {
+    const definition = createNativeCursorToolDefinition(toolName, getCwd());
+    pi.registerTool(wrapNativeCursorTool(definition, () => createNativeCursorToolDefinition(toolName, getCwd()), state));
 }
 export { CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES, CURSOR_REPLAY_TOOL_NAMES };

package/dist/cursor-pi-tool-bridge-constants.js

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

package/dist/cursor-pi-tool-bridge-run.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { Server as McpProtocolServer, WebStandardStreamableHTTPServerTransport, } from "@modelcontextprotocol/server";
 import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
-import { MCP_ENDPOINT_ROOT, MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
+import { buildCursorPiBridgeToolCallId, MCP_ENDPOINT_ROOT, MCP_SERVER_NAME, } from "./cursor-pi-tool-bridge-constants.js";
 import { writeCursorPiToolBridgeDiagnostic, } from "./cursor-pi-tool-bridge-diagnostics.js";
 import { resolveCursorPiToolBridgeCallTimeoutMs } from "./cursor-pi-tool-bridge-env.js";
 import { asToolResultMessage, containsKnownMcpToolName, convertPiContentToMcpContent, normalizeMcpArgs, snapshotToolToMcpTool, waitForProtocolFlush, } from "./cursor-pi-tool-bridge-mcp.js";
@@ -15,6 +15,7 @@ export class CursorPiToolBridgeRunImpl {
     registry;
     env;
     endpointPath;
+    runUuid;
     callTimeoutMs;
     knownMcpToolNames;
     knownCursorMcpCallIds = new Set();
@@ -36,7 +37,9 @@ export class CursorPiToolBridgeRunImpl {
         this.enabled = enabled;
         this.onToolRequest = options.onToolRequest;
         this.debugRecorder = options.debugRecorder;
-        this.id = `cursor-pi-bridge-run-${randomUUID()}`;
+        const runUuid = randomUUID();
+        this.runUuid = runUuid;
+        this.id = `cursor-pi-bridge-run-${runUuid}`;
         this.endpointPath = `${MCP_ENDPOINT_ROOT}/${randomUUID()}/mcp`;
         this.callTimeoutMs = resolveCursorPiToolBridgeCallTimeoutMs(env);
         this.knownMcpToolNames = new Set(snapshot.tools.map((tool) => tool.mcpToolName));
@@ -208,11 +211,12 @@ export class CursorPiToolBridgeRunImpl {
             return Promise.reject(new Error("Cursor pi tool bridge run is disposed"));
         this.toolCallCounter += 1;
         const bridgeCallId = `${this.id}-bridge-${this.toolCallCounter}`;
+        const piToolCallId = buildCursorPiBridgeToolCallId(this.runUuid, this.toolCallCounter);
         const request = {
             runId: this.id,
             bridgeCallId,
             cursorMcpCallId,
-            piToolCallId: `${this.id}-tool-${this.toolCallCounter}`,
+            piToolCallId,
             piToolName,
             mcpToolName,
             args: normalizeMcpArgs(argsValue),

package/dist/cursor-pi-tool-bridge-snapshot.js

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

package/dist/cursor-pi-tool-bridge.js

@@ -7,6 +7,8 @@ import { LOOPBACK_HOST, CursorPiToolBridgeRegistry } from "./cursor-pi-tool-brid
 export { resolveCursorPiToolBridgeDebugEnabled } from "./cursor-pi-tool-bridge-diagnostics.js";
 export { CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV, CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV, CURSOR_PI_TOOL_BRIDGE_ENV, resolveCursorPiToolBridgeBuiltinsEnabled, resolveCursorPiToolBridgeCallTimeoutMs, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-env.js";
 export { buildCursorPiToolBridgeSnapshot, buildCursorPiToolBridgeSurfaceSignature, } from "./cursor-pi-tool-bridge-snapshot.js";
+const bridges = new Map();
+const activeCallsByPi = new Map();
 let registeredCursorPiToolBridge;
 const WINDOWS_BRIDGE_ABORT_ENV = "PI_CURSOR_BRIDGE_TOOL_CALL_ID";
 function buildWindowsBridgeBashAbortCommand(command, marker) {
@@ -49,18 +51,27 @@ Get-CimInstance Win32_Process -Filter "Name = 'bash.exe' OR Name = 'sh.exe'" |
     });
 }
 export function registerCursorPiToolBridge(pi) {
-    bridgeToolExecutionAbortTracker.abortAll("Cursor pi tool bridge extension reloaded");
-    void registeredCursorPiToolBridge?.disposeAll("Cursor pi tool bridge extension reloaded");
+    const previous = bridges.get(pi);
+    if (previous) {
+        const reason = "Cursor pi tool bridge extension reloaded";
+        for (const id of activeCallsByPi.get(pi) ?? [])
+            bridgeToolExecutionAbortTracker.abort(id, reason);
+        void previous.disposeAll(reason);
+    }
     const bridge = new CursorPiToolBridgeRegistry(pi);
     registeredCursorPiToolBridge = bridge;
+    bridges.set(pi, bridge);
+    const activeCalls = new Set();
+    activeCallsByPi.set(pi, activeCalls);
     pi.on("tool_call", (event, ctx) => {
-        if (registeredCursorPiToolBridge !== bridge)
+        if (bridges.get(pi) !== bridge)
             return undefined;
         if (!bridge.hasPendingPiToolCallId(event.toolCallId)) {
             return isCursorPiBridgeToolCallId(event.toolCallId)
                 ? { block: true, reason: "Cursor pi bridge tool call is no longer pending" }
                 : undefined;
         }
+        activeCalls.add(event.toolCallId);
         const windowsAbortMarker = installWindowsBridgeBashAbortMarker(event);
         const trackingStarted = bridgeToolExecutionAbortTracker.track(event.toolCallId, {
             signal: ctx.signal,
@@ -77,17 +88,26 @@ export function registerCursorPiToolBridge(pi) {
         return { block: true, reason: "Cursor pi bridge tool execution was aborted before it started" };
     });
     pi.on("tool_result", (event) => {
-        bridgeToolExecutionAbortTracker.finish(event.toolCallId);
+        if (activeCalls.delete(event.toolCallId))
+            bridgeToolExecutionAbortTracker.finish(event.toolCallId);
     });
     pi.on("session_shutdown", async (event) => {
+        if (bridges.get(pi) !== bridge)
+            return;
         const reason = `Cursor pi tool bridge session shutdown: ${event.reason}`;
-        bridgeToolExecutionAbortTracker.abortAll(reason);
+        for (const id of activeCalls)
+            bridgeToolExecutionAbortTracker.abort(id, reason);
+        activeCalls.clear();
+        bridges.delete(pi);
+        activeCallsByPi.delete(pi);
+        if (registeredCursorPiToolBridge === bridge)
+            registeredCursorPiToolBridge = [...bridges.values()].at(-1);
         await bridge.disposeAll(reason);
     });
     return bridge;
 }
-export function getRegisteredCursorPiToolBridge() {
-    return registeredCursorPiToolBridge;
+export function getRegisteredCursorPiToolBridge(pi) {
+    return pi ? bridges.get(pi) : registeredCursorPiToolBridge;
 }
 export const __testUtils = {
     CURSOR_PI_TOOL_BRIDGE_ENV,
@@ -116,8 +136,10 @@ export const __testUtils = {
     },
     resetRegisteredBridgeForTests() {
         bridgeToolExecutionAbortTracker.abortAll("Cursor pi tool bridge test reset");
-        const bridge = registeredCursorPiToolBridge;
+        const registered = [...bridges.values()];
+        bridges.clear();
+        activeCallsByPi.clear();
         registeredCursorPiToolBridge = undefined;
-        return bridge?.disposeAll("Cursor pi tool bridge test reset") ?? Promise.resolve();
+        return Promise.all(registered.map((bridge) => bridge.disposeAll("Cursor pi tool bridge test reset")));
     },
 };

package/dist/cursor-provider-binding.js

@@ -0,0 +1,58 @@
+import { CURSOR_API_KEY_CONFIG_VALUE } from "./cursor-api-key.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. Bind this session's extensions and refresh Cursor models/reload it; 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 };
+    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) => {
+        // 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),
+        });
+    });
+    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),
+        };
+    });
+    pi.on("session_start", () => { if (!binding.closed)
+        binding.active = true; });
+    pi.on("session_shutdown", () => { binding.active = false; binding.closed = true; });
+    return (models) => {
+        if (binding.closed)
+            return;
+        pi.registerProvider("cursor", {
+            name: "Cursor", baseUrl: "https://cursor.com", apiKey: CURSOR_API_KEY_CONFIG_VALUE,
+            api: "cursor-sdk", models, streamSimple: stream,
+        });
+    };
+}

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) {
@@ -284,23 +284,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

@@ -30,11 +30,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 +125,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 +142,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 +154,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 +173,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 +192,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 +219,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 +229,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 +309,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 +351,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 +377,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", {

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
@@ -104,6 +108,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 +127,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 +138,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 +154,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,
             });
         });
     }