pi-cursor-sdk 0.4.0 → 0.5.2

package/dist/cursor-live-run-coordinator.js

@@ -153,6 +153,7 @@ export function createCursorLiveRunCoordinator(deps) {
                 bridgeRun: params.bridgeRun,
                 sessionBridgeRun: params.sessionBridgeRun,
                 sessionAgentScopeKey,
+                nativeDisplay: params.nativeDisplay,
                 accounting: createCursorLiveRunAccountingState(params.promptInputTokens),
                 pendingEvents: [],
                 textDeltas: params.textDeltas ?? [],
@@ -170,6 +171,11 @@ export function createCursorLiveRunCoordinator(deps) {
                 leased: false,
                 leaseQueue: [],
             });
+            const state = getPrivateState(run);
+            state.pendingCallUnsubscribers = [...new Set([run.bridgeRun, run.sessionBridgeRun])].flatMap((bridge) => bridge ? [bridge.onPendingToolCallsChanged(() => {
+                    if (state.idleDisposeRequested || state.idleDisposeTimer)
+                        coordinator.requestIdleDispose(run);
+                })] : []);
             pendingRuns.set(run.id, run);
             pendingRunIdsByScopeKey.set(sessionAgentScopeKey, run.id);
             return run;
@@ -270,7 +276,10 @@ export function createCursorLiveRunCoordinator(deps) {
             run.accounting = taken.state;
             return taken.sdkTurnUsage;
         },
-        getPendingFromContext(context, getReplayId) {
+        getPendingFromContext(context, getReplayId, scopeKey) {
+            const run = getUndisposed(pendingRunIdsByScopeKey.get(scopeKey));
+            if (!run)
+                return undefined;
             const messages = getCursorConversationMessages(context);
             let index = messages.length - 1;
             while (index >= 0 && messages[index]?.role === "user") {
@@ -280,18 +289,8 @@ export function createCursorLiveRunCoordinator(deps) {
                 const message = messages[index];
                 if (message.role !== "toolResult")
                     break;
-                const replayId = getReplayId(message.toolCallId);
-                if (replayId) {
-                    const replayRun = getUndisposed(replayId);
-                    if (replayRun)
-                        return replayRun;
-                }
-                for (const run of pendingRuns.values()) {
-                    if (run.disposed)
-                        continue;
-                    if (run.bridgeRun?.hasPendingPiToolCallId(message.toolCallId))
-                        return run;
-                }
+                if (matchesCursorLiveRunToolResult(run, message, getReplayId))
+                    return run;
             }
             return undefined;
         },
@@ -349,10 +348,16 @@ export function createCursorLiveRunCoordinator(deps) {
             const state = getPrivateState(run);
             clearIdleDisposeTimer(run);
             state.idleDisposeRequested = true;
-            if (state.leased || state.leaseQueue.length > 0)
+            if (state.leased || state.leaseQueue.length > 0 ||
+                [run.bridgeRun, run.sessionBridgeRun].some((bridge) => bridge?.hasPendingToolCalls()))
                 return;
-            state.idleDisposeRequested = false;
             state.idleDisposeTimer = setTimeout(() => {
+                state.idleDisposeTimer = undefined;
+                if (state.leased || state.leaseQueue.length > 0 ||
+                    [run.bridgeRun, run.sessionBridgeRun].some((bridge) => bridge?.hasPendingToolCalls())) {
+                    coordinator.requestIdleDispose(run);
+                    return;
+                }
                 void coordinator.release(run).catch(() => {
                     // Idle dispose must not leave release failures as unhandled rejections.
                 });
@@ -368,6 +373,15 @@ export function createCursorLiveRunCoordinator(deps) {
                     return;
                 const abandoned = !isSuccessfulCursorLiveRun(run);
                 run.disposed = true;
+                for (const unsubscribe of state.pendingCallUnsubscribers ?? []) {
+                    try {
+                        unsubscribe();
+                    }
+                    catch {
+                        // Cleanup continues even if an observer cannot detach.
+                    }
+                }
+                state.pendingCallUnsubscribers = [];
                 unregister(run);
                 clearIdleDisposeTimer(run);
                 state.idleDisposeRequested = false;
@@ -389,12 +403,14 @@ export function createCursorLiveRunCoordinator(deps) {
                 }
                 if (abandoned) {
                     if (!run.done) {
+                        const usageCompletion = run.onAbandon?.();
                         try {
                             await cancelCursorLiveSdkRun(run);
                         }
                         catch {
                             // cancellation failure should not block session-agent abandonment
                         }
+                        await usageCompletion;
                     }
                     await deps.abandonSessionAgent(run.sessionAgentScopeKey);
                 }

package/dist/cursor-mcp-timeout-override.js

@@ -60,7 +60,9 @@ export function isCursorSdkMcpToolTimeoutStack(stack) {
 export function isCursorSdkMcpConnectTimeoutStack(stack) {
     if (!stack || !isCursorSdkMcpProtocolTimeoutStack(stack))
         return false;
-    return /\bClient\.(?:connect|listTools)\b|\bMcpSdkClient\.getTools\b/.test(stack);
+    // SDK 1.0.36 minifies the Client class name; the protocol method and SDK
+    // frame, not that constructor's spelling, establish this timeout purpose.
+    return /^\s*at (?:[\w$]+\.)?(?:connect|listTools|getTools)\s*\(.*(?:node_modules[/\\]@cursor[/\\]sdk|@cursor\/sdk\/dist)/m.test(stack);
 }
 function isCursorSdkDefaultMcpTimeout(delay) {
     return typeof delay === "number" && delay === CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS;

package/dist/cursor-native-replay-routing.js

@@ -8,7 +8,7 @@ export function isNativeToolActiveInContext(toolName, activeToolNames) {
  * Extension resync (pi active tools) is separate; this uses context.tools snapshot only.
  */
 export function resolveNativeReplayDisposition(input) {
-    if (!input.useNativeToolReplay || !canRenderCursorToolNatively(input.toolName)) {
+    if (!input.useNativeToolReplay || !(input.registeredToolNames?.has(input.toolName) ?? canRenderCursorToolNatively(input.toolName))) {
         return "transcript_trace";
     }
     if (isNativeToolActiveInContext(input.toolName, input.activeToolNames) && input.hasLiveRun) {

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

@@ -2,7 +2,7 @@ import { arePiToolsDisabled } from "./cursor-active-tools.js";
 import { CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES, isNativeCursorToolName, NATIVE_CURSOR_TOOL_NAMES, } from "./cursor-native-tool-names.js";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle } from "./cursor-model-lifecycle.js";
-import { isCursorNativeToolDisplayRequested, isCursorNativeToolRegistrationRequested, NATIVE_CURSOR_TOOL_DISPLAY_ENV, readBooleanEnv, registeredNativeToolNames, setCursorNativeToolDisplayRuntimeRequested, skippedNativeToolNames, } from "./cursor-native-tool-display-state.js";
+import { isCursorNativeToolDisplayRequested, isCursorNativeToolRegistrationRequested, NATIVE_CURSOR_TOOL_DISPLAY_ENV, readBooleanEnv, getCursorNativeToolDisplayState, registerCursorNativeToolDisplayState, setCursorNativeToolDisplayRuntimeRequested, } from "./cursor-native-tool-display-state.js";
 import { isCursorReplayToolName } from "./cursor-tool-presentation-registry.js";
 import { registerNativeCursorTool } from "./cursor-native-tool-display-tools.js";
 export const CURSOR_CORE_PI_REPLAY_TOOL_NAMES = ["read", "bash", "edit", "write"];
@@ -10,22 +10,37 @@ const CORE_PI_TOOL_NAMES = new Set(CURSOR_CORE_PI_REPLAY_TOOL_NAMES);
 function isCursorCorePiReplayToolName(toolName) {
     return CORE_PI_TOOL_NAMES.has(toolName);
 }
+// Pi filters getAllTools even after registration; new/reloaded extensions receive a new API.
+const filteredRegistrations = new WeakMap();
 function hasNonBuiltinTool(pi, toolName) {
     const existingTool = pi.getAllTools().find((tool) => tool.name === toolName);
     return existingTool !== undefined && existingTool.sourceInfo.source !== "builtin";
 }
-function registerNativeCursorToolsFromSet(pi, toolNames) {
+function registerNativeCursorToolsFromSet(pi, toolNames, getCwd) {
+    const state = getCursorNativeToolDisplayState(pi);
+    const { registeredNativeToolSources, skippedNativeToolNames } = state;
+    let filteredToolNames = filteredRegistrations.get(pi);
+    if (!filteredToolNames) {
+        filteredToolNames = new Set();
+        filteredRegistrations.set(pi, filteredToolNames);
+    }
     const newlySkippedToolNames = [];
     for (const toolName of toolNames) {
-        if (registeredNativeToolNames.has(toolName) || skippedNativeToolNames.has(toolName))
+        if (registeredNativeToolSources.has(toolName) || filteredToolNames.has(toolName))
             continue;
         if (hasNonBuiltinTool(pi, toolName)) {
-            skippedNativeToolNames.add(toolName);
-            newlySkippedToolNames.push(toolName);
+            if (!skippedNativeToolNames.has(toolName)) {
+                skippedNativeToolNames.add(toolName);
+                newlySkippedToolNames.push(toolName);
+            }
             continue;
         }
-        registerNativeCursorTool(pi, toolName);
-        registeredNativeToolNames.add(toolName);
+        registerNativeCursorTool(pi, toolName, getCwd, state);
+        const registeredTool = pi.getAllTools().find((tool) => tool.name === toolName);
+        if (registeredTool)
+            registeredNativeToolSources.set(toolName, registeredTool.sourceInfo);
+        else
+            filteredToolNames.add(toolName);
     }
     return newlySkippedToolNames;
 }
@@ -34,15 +49,13 @@ function notifySkippedNativeCursorToolsIfNeeded(ctx, skippedToolNames) {
         return;
     ctx.ui.notify(`Cursor native tool replay skipped for ${skippedToolNames.join(", ")} because another extension already provides ${skippedToolNames.length === 1 ? "that tool" : "those tools"}. Cursor will use scrubbed activity transcripts for skipped tools.`, "warning");
 }
-function hasAttemptedNativeCursorToolRegistration() {
-    return registeredNativeToolNames.size > 0 || skippedNativeToolNames.size > 0;
-}
 function removeRegisteredNonCoreNativeCursorTools(pi) {
-    if (registeredNativeToolNames.size === 0)
+    const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+    if (registeredNativeToolSources.size === 0)
         return;
     const activeToolNames = new Set(pi.getActiveTools());
     let changed = false;
-    for (const toolName of registeredNativeToolNames) {
+    for (const toolName of registeredNativeToolSources.keys()) {
         if (isCursorCorePiReplayToolName(toolName))
             continue;
         if (!activeToolNames.delete(toolName))
@@ -53,7 +66,8 @@ function removeRegisteredNonCoreNativeCursorTools(pi) {
         pi.setActiveTools([...activeToolNames]);
 }
 export function syncRegisteredNativeCursorToolsForModel(pi, model) {
-    if (registeredNativeToolNames.size === 0)
+    const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+    if (registeredNativeToolSources.size === 0)
         return;
     if (!isCursorModel(model)) {
         removeRegisteredNonCoreNativeCursorTools(pi);
@@ -63,7 +77,7 @@ export function syncRegisteredNativeCursorToolsForModel(pi, model) {
         return;
     const activeToolNames = new Set(pi.getActiveTools());
     let changed = false;
-    for (const toolName of registeredNativeToolNames) {
+    for (const toolName of registeredNativeToolSources.keys()) {
         if (isCursorReplayToolName(toolName) && !CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES.some((activeReplayToolName) => activeReplayToolName === toolName))
             continue;
         if (activeToolNames.has(toolName))
@@ -74,29 +88,39 @@ export function syncRegisteredNativeCursorToolsForModel(pi, model) {
     if (changed)
         pi.setActiveTools([...activeToolNames]);
 }
-function ensureNativeCursorToolsRegisteredForModel(pi, ctx) {
-    if (!isCursorModel(ctx.model) || hasAttemptedNativeCursorToolRegistration())
+function ensureNativeCursorToolsRegisteredForModel(pi, ctx, getCwd) {
+    if (!isCursorModel(ctx.model))
         return;
     const nonCoreToolNames = NATIVE_CURSOR_TOOL_NAMES.filter((toolName) => !isCursorCorePiReplayToolName(toolName));
     const skippedToolNames = [
-        ...registerNativeCursorToolsFromSet(pi, nonCoreToolNames),
-        ...registerNativeCursorToolsFromSet(pi, CURSOR_CORE_PI_REPLAY_TOOL_NAMES),
+        ...registerNativeCursorToolsFromSet(pi, nonCoreToolNames, getCwd),
+        ...registerNativeCursorToolsFromSet(pi, CURSOR_CORE_PI_REPLAY_TOOL_NAMES, getCwd),
     ];
     notifySkippedNativeCursorToolsIfNeeded(ctx, skippedToolNames);
 }
-function ensureThenSyncNativeCursorToolsForModel(pi, ctx) {
+function ensureThenSyncNativeCursorToolsForModel(pi, ctx, getCwd) {
+    const { registeredNativeToolSources } = getCursorNativeToolDisplayState(pi);
+    const currentTools = pi.getAllTools();
+    for (const [toolName, sourceInfo] of registeredNativeToolSources) {
+        if (!currentTools.some((tool) => tool.name === toolName && tool.sourceInfo === sourceInfo)) {
+            registeredNativeToolSources.delete(toolName);
+        }
+    }
     const requested = isCursorNativeToolRegistrationRequested(ctx.mode);
-    setCursorNativeToolDisplayRuntimeRequested(requested);
+    setCursorNativeToolDisplayRuntimeRequested(requested, pi);
     if (!requested) {
         removeRegisteredNonCoreNativeCursorTools(pi);
         return;
     }
-    ensureNativeCursorToolsRegisteredForModel(pi, ctx);
+    ensureNativeCursorToolsRegisteredForModel(pi, ctx, getCwd);
     syncRegisteredNativeCursorToolsForModel(pi, ctx.model);
 }
 export function registerCursorNativeToolDisplay(pi) {
+    registerCursorNativeToolDisplayState(pi);
+    let cwd = process.cwd();
     registerCursorModelLifecycle(pi, (ctx) => {
-        ensureThenSyncNativeCursorToolsForModel(pi, ctx);
+        cwd = ctx.cwd;
+        ensureThenSyncNativeCursorToolsForModel(pi, ctx, () => cwd);
     });
 }
 export { isNativeCursorToolName, isCursorNativeToolDisplayRequested };

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

@@ -1,10 +1,36 @@
 import { parseOptionalEnvBoolean } from "./cursor-env-boolean.js";
+import { normalizeCursorToolName } from "./cursor-tool-presentation-registry.js";
 export const NATIVE_CURSOR_TOOL_DISPLAY_ENV = "PI_CURSOR_NATIVE_TOOL_DISPLAY";
 export const NATIVE_CURSOR_TOOL_REGISTRATION_ENV = "PI_CURSOR_REGISTER_NATIVE_TOOLS";
-export const registeredNativeToolNames = new Set();
-export const skippedNativeToolNames = new Set();
+function createDisplayState() {
+    return { registeredNativeToolSources: new Map(), skippedNativeToolNames: new Set(), runtimeRequested: false, resultIds: new Set() };
+}
+let lastDisplayState = createDisplayState();
+const displayStates = new Map();
+// IDs index results; the owning display state and tool authorize consumption.
 export const nativeToolResults = new Map();
-let nativeToolDisplayRuntimeRequested = false;
+const resultStates = new Map();
+export function getCursorNativeToolDisplayState(pi) {
+    if (!pi)
+        return lastDisplayState;
+    const state = displayStates.get(pi);
+    if (!state)
+        throw new Error("Cursor native display binding is no longer active.");
+    return state;
+}
+export function registerCursorNativeToolDisplayState(pi) {
+    const state = createDisplayState();
+    displayStates.set(pi, state);
+    lastDisplayState = state;
+    pi.on("session_shutdown", () => {
+        displayStates.delete(pi);
+        for (const id of state.resultIds) {
+            nativeToolResults.delete(id);
+            resultStates.delete(id);
+        }
+        state.resultIds.clear();
+    });
+}
 export function readBooleanEnv(name, env = process.env) {
     return parseOptionalEnvBoolean(env[name]);
 }
@@ -19,34 +45,42 @@ export function isCursorNativeToolDisplayRequested(mode) {
 export function isCursorNativeToolRegistrationRequested(mode) {
     return mode !== "print" && readBooleanEnv(NATIVE_CURSOR_TOOL_REGISTRATION_ENV) !== false && isCursorNativeToolDisplayRequested(mode);
 }
-export function setCursorNativeToolDisplayRuntimeRequested(requested) {
-    nativeToolDisplayRuntimeRequested = requested;
+export function setCursorNativeToolDisplayRuntimeRequested(requested, pi) {
+    getCursorNativeToolDisplayState(pi).runtimeRequested = requested;
 }
 export function isCursorNativeToolDisplayEnabled() {
-    return registeredNativeToolNames.size > 0;
+    return getCursorNativeToolDisplayState().registeredNativeToolSources.size > 0;
 }
-export function isCursorNativeToolDisplayRuntimeEnabled() {
-    return nativeToolDisplayRuntimeRequested && readBooleanEnv(NATIVE_CURSOR_TOOL_DISPLAY_ENV) !== false && registeredNativeToolNames.size > 0;
+export function isCursorNativeToolDisplayRuntimeEnabled(state = getCursorNativeToolDisplayState()) {
+    return state.runtimeRequested && readBooleanEnv(NATIVE_CURSOR_TOOL_DISPLAY_ENV) !== false && state.registeredNativeToolSources.size > 0;
 }
 export function canRenderCursorToolNatively(toolName) {
-    return registeredNativeToolNames.has(toolName);
+    return getCursorNativeToolDisplayState().registeredNativeToolSources.has(toolName);
 }
-export function isRegisteredCursorNativeToolName(toolName) {
-    return registeredNativeToolNames.has(toolName);
+export function isRegisteredCursorNativeToolName(toolName, pi) {
+    return (pi ? displayStates.get(pi) : lastDisplayState)?.registeredNativeToolSources.has(toolName) === true;
 }
-export function recordCursorNativeToolDisplay(item) {
-    if (!canRenderCursorToolNatively(item.toolName))
+export function recordCursorNativeToolDisplay(item, state = getCursorNativeToolDisplayState()) {
+    if (!state.registeredNativeToolSources.has(item.toolName))
         return false;
     nativeToolResults.set(item.id, item);
+    resultStates.set(item.id, state);
+    state.resultIds.add(item.id);
     return true;
 }
 export function deleteCursorNativeToolDisplay(id) {
     nativeToolResults.delete(id);
+    resultStates.get(id)?.resultIds.delete(id);
+    resultStates.delete(id);
 }
-export function consumeCursorNativeToolDisplay(id) {
+export function consumeCursorNativeToolDisplay(id, state, toolName) {
     const item = nativeToolResults.get(id);
-    if (item)
-        nativeToolResults.delete(id);
+    if (item) {
+        if (resultStates.get(id) !== state || normalizeCursorToolName(item.toolName) !== normalizeCursorToolName(toolName)) {
+            throw new Error(`No owned Cursor ${toolName} result was available. This replay-only call does not execute work.`);
+        }
+        deleteCursorNativeToolDisplay(id);
+    }
     return item;
 }
 export function isCursorReplayToolCallId(toolCallId) {
@@ -57,14 +91,15 @@ export function isCursorFileMutationToolName(toolName) {
 }
 export const __testUtils = {
     nativeToolResultCount: () => nativeToolResults.size,
-    registerNativeToolNameForTests(toolName) {
-        nativeToolDisplayRuntimeRequested = true;
-        registeredNativeToolNames.add(toolName);
+    registerNativeToolNameForTests(toolName, pi) {
+        const state = getCursorNativeToolDisplayState(pi);
+        state.runtimeRequested = true;
+        state.registeredNativeToolSources.set(toolName, { path: "test", source: "inline", scope: "temporary", origin: "top-level" });
     },
     reset() {
-        nativeToolDisplayRuntimeRequested = false;
-        registeredNativeToolNames.clear();
-        skippedNativeToolNames.clear();
+        lastDisplayState = createDisplayState();
+        displayStates.clear();
         nativeToolResults.clear();
+        resultStates.clear();
     },
 };

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,10 +15,12 @@ export class CursorPiToolBridgeRunImpl {
     registry;
     env;
     endpointPath;
+    runUuid;
     callTimeoutMs;
     knownMcpToolNames;
     knownCursorMcpCallIds = new Set();
     queuedRequests = [];
+    pendingToolCallListeners = new Set();
     pendingByPiToolCallId = new Map();
     pendingByBridgeCallId = new Map();
     pendingByCursorMcpCallId = new Map();
@@ -36,7 +38,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));
@@ -126,6 +130,23 @@ export class CursorPiToolBridgeRunImpl {
     hasPendingPiToolCallId(piToolCallId) {
         return this.pendingByPiToolCallId.has(piToolCallId);
     }
+    hasPendingToolCalls() {
+        return this.pendingCount() > 0;
+    }
+    onPendingToolCallsChanged(listener) {
+        this.pendingToolCallListeners.add(listener);
+        return () => { this.pendingToolCallListeners.delete(listener); };
+    }
+    notifyPendingToolCallsChanged() {
+        for (const listener of this.pendingToolCallListeners) {
+            try {
+                listener();
+            }
+            catch {
+                // Observers must not prevent call registration or protocol settlement.
+            }
+        }
+    }
     cancelPendingPiToolCallId(piToolCallId, reason) {
         const pending = this.pendingByPiToolCallId.get(piToolCallId);
         if (!pending)
@@ -170,6 +191,7 @@ export class CursorPiToolBridgeRunImpl {
             return;
         this.disposed = true;
         this.cancel("Cursor pi tool bridge run disposed");
+        this.pendingToolCallListeners.clear();
         await waitForProtocolFlush();
         await Promise.allSettled([
             this.mcpTransport?.close(),
@@ -208,11 +230,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),
@@ -237,6 +260,7 @@ export class CursorPiToolBridgeRunImpl {
             this.pendingByBridgeCallId.set(request.bridgeCallId, pending);
             this.pendingByCursorMcpCallId.set(cursorMcpCallId, pending);
             this.knownCursorMcpCallIds.add(cursorMcpCallId);
+            this.notifyPendingToolCallsChanged();
             pending.timeout = setTimeout(() => {
                 const reason = `Cursor pi bridge CallTool timed out after ${this.callTimeoutMs} ms`;
                 this.rejectAndAbortPending(pending, new Error(reason));
@@ -348,5 +372,6 @@ export class CursorPiToolBridgeRunImpl {
         const queuedIndex = this.queuedRequests.findIndex((request) => request.bridgeCallId === pending.request.bridgeCallId);
         if (queuedIndex >= 0)
             this.queuedRequests.splice(queuedIndex, 1);
+        this.notifyPendingToolCallsChanged();
     }
 }

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

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { asRecord } from "./cursor-record-utils.js";
+import { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
 import { buildCursorPiToolBridgeSnapshot, buildCursorPiToolBridgeSurfaceSignature, createEmptySnapshot, resolveCursorPiToolBridgeBuiltinsEnabled, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-snapshot.js";
 export const LOOPBACK_HOST = "127.0.0.1";
 const HTTP_SERVER_CLOSE_GRACE_MS = 250;
@@ -33,7 +34,6 @@ export class CursorPiToolBridgeRegistry {
                 exposeOverlappingBuiltins: resolveCursorPiToolBridgeBuiltinsEnabled(this.env),
             })
             : createEmptySnapshot();
-        const { CursorPiToolBridgeRunImpl } = await import("./cursor-pi-tool-bridge-run.js");
         const run = new CursorPiToolBridgeRunImpl(this, this.env, snapshot, bridgeEnabled && snapshot.tools.length > 0, options);
         this.runs.add(run);
         await run.start();

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")));
     },
 };