pi-cursor-sdk 0.5.2 → 0.5.4

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

@@ -36,7 +36,7 @@ function normalizeConnectTimeoutMs(timeoutMs) {
         return DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
     return Math.min(Math.max(Math.trunc(timeoutMs), MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS), CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS);
 }
-export function resolveCursorMcpConnectTimeoutMs(env = process.env) {
+function resolveCursorMcpConnectTimeoutMs(env = process.env) {
     const explicitMs = parsePositiveNumber(env[CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV]);
     if (explicitMs !== undefined)
         return normalizeConnectTimeoutMs(explicitMs);
@@ -51,16 +51,16 @@ function isCursorSdkMcpProtocolTimeoutStack(stack) {
     return (/(?:node_modules[/\\]@cursor[/\\]sdk|node_modules\/\@cursor\/sdk|@cursor\/sdk\/dist)/.test(stack) &&
         /\b_setupTimeout\b|\bProtocol\._setupTimeout\b/.test(stack));
 }
-export function isCursorSdkMcpToolTimeoutStack(stack) {
+function isCursorSdkMcpToolTimeoutStack(stack) {
     if (!stack)
         return false;
     return (isCursorSdkMcpProtocolTimeoutStack(stack) &&
         /\bcallTool\b|\bClient\.callTool\b|\bMcpSdkClient\.callTool\b/.test(stack));
 }
-export function isCursorSdkMcpConnectTimeoutStack(stack) {
+function isCursorSdkMcpConnectTimeoutStack(stack) {
     if (!stack || !isCursorSdkMcpProtocolTimeoutStack(stack))
         return false;
-    // SDK 1.0.36 minifies the Client class name; the protocol method and SDK
+    // The SDK 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);
 }
@@ -83,9 +83,9 @@ function patchedSetTimeout(handler, delay, ...args) {
     }
     return Reflect.apply(delegate, globalThis, [handler, nextDelay, ...args]);
 }
-export function installCursorMcpToolTimeoutOverride(options = {}) {
-    installedToolTimeoutMs = normalizeOverrideTimeoutMs(options.timeoutMs ?? resolveCursorMcpToolTimeoutMs(options.env));
-    installedConnectTimeoutMs = normalizeConnectTimeoutMs(options.connectTimeoutMs ?? resolveCursorMcpConnectTimeoutMs(options.env));
+export function installCursorMcpToolTimeoutOverride() {
+    installedToolTimeoutMs = resolveCursorMcpToolTimeoutMs();
+    installedConnectTimeoutMs = resolveCursorMcpConnectTimeoutMs();
     if (!originalSetTimeout) {
         originalSetTimeout = globalThis.setTimeout;
         globalThis.setTimeout = patchedSetTimeout;
@@ -105,14 +105,3 @@ export function restoreCursorMcpToolTimeoutOverride() {
     installedToolTimeoutMs = DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
     installedConnectTimeoutMs = DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
 }
-export const cursorMcpToolTimeoutOverrideDefaults = {
-    cursorSdkDefaultTimeoutMs: CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS,
-    defaultOverrideTimeoutMs: DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS,
-    defaultConnectTimeoutMs: DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS,
-    minConnectTimeoutMs: MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS,
-    maxNodeTimerDelayMs: MAX_NODE_TIMER_DELAY_MS,
-    timeoutMsEnv: CURSOR_MCP_TOOL_TIMEOUT_MS_ENV,
-    timeoutSecondsEnv: CURSOR_MCP_TOOL_TIMEOUT_SECONDS_ENV,
-    connectTimeoutMsEnv: CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV,
-    connectTimeoutSecondsEnv: CURSOR_MCP_CONNECT_TIMEOUT_SECONDS_ENV,
-};

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

@@ -8,9 +8,9 @@ import { inferImageMimeType } from "./cursor-tool-result-display-readers.js";
 import { LOCAL_READ_PREVIEW_NOTICE, isLocalReadPreviewContent } from "./cursor-transcript-utils.js";
 import { CURSOR_REPLAY_ACTIVITY_TOOL_NAME, getCursorReplayCallSummary, shouldShowCursorReplayCollapsedExpandHint, } from "./cursor-tool-presentation-registry.js";
 import { CURSOR_REPLAY_GENERATE_IMAGE_RESULT_TITLE, isCursorReplayGenerateImageDetails, isCursorReplayActivityDetails, parseCursorReplayToolDetails, } from "./cursor-replay-tool-details.js";
-export { isCursorReplayNativeEditDetails, isCursorReplayGenerateImageDetails, isCursorReplayActivityDetails, isCursorReplayNativeWriteDetails, parseCursorReplayToolDetails, } from "./cursor-replay-tool-details.js";
+export { isCursorReplayNativeEditDetails, isCursorReplayNativeWriteDetails, parseCursorReplayToolDetails, } from "./cursor-replay-tool-details.js";
 export const CURSOR_REPLAY_COLLAPSED_PREVIEW_LINES = 8;
-export const CURSOR_REPLAY_PREVIEW_MAX_CHARS = 4000;
+const CURSOR_REPLAY_PREVIEW_MAX_CHARS = 4000;
 export const CURSOR_REPLAY_PREVIEW_MAX_LINE_CHARS = 240;
 const CURSOR_REPLAY_HIGHLIGHT_MAX_CHARS = 12000;
 export const cursorReplayToolSchema = Type.Object({}, { additionalProperties: true });
@@ -40,7 +40,7 @@ function buildImageReplayComponent(text, imageData, mimeType, filename, theme) {
         },
     };
 }
-export function getCursorReplayPath(args, details) {
+function getCursorReplayPath(args, details) {
     const argPath = args?.path;
     return details?.path ?? (typeof argPath === "string" && argPath.trim() ? argPath : "unknown");
 }
@@ -202,7 +202,7 @@ function formatCursorReplayActivityPreview(details, text, theme, maxLines, strip
     }
     return stripHeader ? formatCursorReplayPreview(text, theme, maxLines, true) : formatMutedBlock(text, theme);
 }
-export function formatCursorReplayPreview(text, theme, maxLines = CURSOR_REPLAY_COLLAPSED_PREVIEW_LINES, stripHeader = true) {
+function formatCursorReplayPreview(text, theme, maxLines = CURSOR_REPLAY_COLLAPSED_PREVIEW_LINES, stripHeader = true) {
     const body = (stripHeader ? stripCursorReplayHeader(text) : text).trimEnd();
     if (!body)
         return undefined;
@@ -240,7 +240,7 @@ function getCursorReplayCardTitle(toolName, args) {
     }
     return "Cursor activity";
 }
-export function renderCursorReplayCall(toolName, args, theme, isPartial) {
+function renderCursorReplayCall(toolName, args, theme, isPartial) {
     if (!isPartial)
         return new Text("", 0, 0);
     let text = theme.fg("toolTitle", theme.bold(`${getCursorReplayCardTitle(toolName, args)} `));

package/dist/cursor-native-tools.js

@@ -0,0 +1,11 @@
+import { parseEnvBoolean } from "./cursor-env-boolean.js";
+export const CURSOR_NATIVE_TOOLS_ENV = "PI_CURSOR_NATIVE_TOOLS";
+/** Default preserves the SDK toolset; false selects the public MCP-only main loop. */
+export function resolveCursorNativeToolsEnabled(env = process.env) {
+    return parseEnvBoolean(env[CURSOR_NATIVE_TOOLS_ENV], true);
+}
+export function assertCursorNativeToolsRuntime(runtime, nativeToolsEnabled) {
+    if (runtime === "cloud" && !nativeToolsEnabled) {
+        throw new Error("PI_CURSOR_NATIVE_TOOLS=0 requires local runtime; Cursor Cloud does not support the SDK tools restriction. Select local runtime or remove the opt-out.");
+    }
+}

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

@@ -15,6 +15,10 @@ function assertNeverDiagnosticEvent(_event) {
 }
 export function serializeCursorPiToolBridgeDiagnostic(event) {
     switch (event.event) {
+        case "mcp_initialized":
+            return { event: event.event, runId: event.runId };
+        case "mcp_tools_list":
+            return { event: event.event, runId: event.runId, toolCount: event.toolCount };
         case "run_created":
             return {
                 event: event.event,

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

@@ -1,8 +1,8 @@
 import { parseEnvBoolean } from "./cursor-env-boolean.js";
 import { resolveCursorMcpToolTimeoutMs } from "./cursor-mcp-timeout-override.js";
 export const CURSOR_PI_TOOL_BRIDGE_ENV = "PI_CURSOR_PI_TOOL_BRIDGE";
-export const CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV = "PI_CURSOR_EXPOSE_BUILTIN_TOOLS";
-export const CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV = "PI_CURSOR_PI_BRIDGE_CALL_TIMEOUT_MS";
+const CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV = "PI_CURSOR_EXPOSE_BUILTIN_TOOLS";
+const CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV = "PI_CURSOR_PI_BRIDGE_CALL_TIMEOUT_MS";
 export function resolveCursorPiToolBridgeEnabled(env = process.env) {
     return parseEnvBoolean(env[CURSOR_PI_TOOL_BRIDGE_ENV], true);
 }
@@ -16,3 +16,26 @@ export function resolveCursorPiToolBridgeCallTimeoutMs(env = process.env) {
         return mcpToolTimeoutMs;
     return Math.min(Math.max(Math.trunc(parsed), 1), mcpToolTimeoutMs);
 }
+const CURSOR_PI_TOOL_BRIDGE_HOST_ENV = "PI_CURSOR_PI_TOOL_BRIDGE_HOST";
+const CURSOR_PI_TOOL_BRIDGE_PORT_ENV = "PI_CURSOR_PI_TOOL_BRIDGE_PORT";
+const DEFAULT_URL_HOST = "127.0.0.1";
+const PORT_PATTERN = /^\d{1,5}$/;
+export function resolveCursorPiToolBridgeUrlHost(env = process.env) {
+    return env[CURSOR_PI_TOOL_BRIDGE_HOST_ENV]?.trim().toLowerCase() === "localhost" ? "localhost" : DEFAULT_URL_HOST;
+}
+function parsePort(text) {
+    if (!PORT_PATTERN.test(text))
+        return undefined;
+    const port = Number(text);
+    return port >= 1 && port <= 65535 ? port : undefined;
+}
+export function resolveCursorPiToolBridgePortRange(env = process.env) {
+    const parts = env[CURSOR_PI_TOOL_BRIDGE_PORT_ENV]?.trim().split("-");
+    if (!parts || parts.length > 2)
+        return undefined;
+    const first = parsePort(parts[0]);
+    const last = parts.length === 2 ? parsePort(parts[1]) : first;
+    if (first === undefined || last === undefined || first > last)
+        return undefined;
+    return { first, last };
+}

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

@@ -208,9 +208,16 @@ export class CursorPiToolBridgeRunImpl {
         const transport = new WebStandardStreamableHTTPServerTransport({
             sessionIdGenerator: randomUUID,
         });
-        server.setRequestHandler("tools/list", async () => ({
-            tools: this.snapshot.tools.map(snapshotToolToMcpTool),
-        }));
+        // ponytail: server-side receipts only, not SDK/model consumption or ongoing
+        // connection health; upgrade when Cursor exposes public MCP lifecycle callbacks.
+        server.oninitialized = () => {
+            this.emitDiagnostic({ event: "mcp_initialized", runId: this.id });
+        };
+        server.setRequestHandler("tools/list", async () => {
+            const tools = this.snapshot.tools.map(snapshotToolToMcpTool);
+            this.emitDiagnostic({ event: "mcp_tools_list", runId: this.id, toolCount: tools.length });
+            return { tools };
+        });
         server.setRequestHandler("tools/call", async (request, context) => {
             return this.enqueueToolRequest(request.params.name, request.params.arguments, String(context.mcpReq.id), context.mcpReq.signal);
         });

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

@@ -1,15 +1,57 @@
 import { createServer } from "node:http";
+import { resolveCursorPiToolBridgePortRange, resolveCursorPiToolBridgeUrlHost, } from "./cursor-pi-tool-bridge-env.js";
 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 LOOPBACK_HOST = "127.0.0.1";
 const HTTP_SERVER_CLOSE_GRACE_MS = 250;
+const EPHEMERAL_BIND_ATTEMPTS = 10;
+function listenOnce(server, port, host = LOOPBACK_HOST) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen({ port, host, ipv6Only: host === "::1" });
+    });
+}
+async function closeServers(servers) {
+    await Promise.all(servers.map(async (server) => {
+        if (!server.listening)
+            return;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(closeTimer);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const closeTimer = setTimeout(() => settle(), HTTP_SERVER_CLOSE_GRACE_MS);
+            closeTimer.unref?.();
+            server.close((error) => settle(error ?? undefined));
+            server.closeIdleConnections();
+            server.closeAllConnections();
+        });
+    }));
+}
 export class CursorPiToolBridgeRegistry {
     pi;
     env;
     runs = new Set();
     routes = new Map();
-    httpServer;
+    httpServers = [];
+    advertisedHost;
     listenPromise;
     serverLifecycle = Promise.resolve();
     constructor(pi, env = process.env) {
@@ -36,7 +78,17 @@ export class CursorPiToolBridgeRegistry {
             : createEmptySnapshot();
         const run = new CursorPiToolBridgeRunImpl(this, this.env, snapshot, bridgeEnabled && snapshot.tools.length > 0, options);
         this.runs.add(run);
-        await run.start();
+        try {
+            await run.start();
+        }
+        catch (error) {
+            try {
+                await run.dispose();
+            }
+            catch { /* Preserve the original startup failure, not a secondary cleanup error. */ }
+            this.runs.delete(run);
+            throw error;
+        }
         run.emitStartDiagnostics(bridgeEnabled);
         return run;
     }
@@ -51,9 +103,9 @@ export class CursorPiToolBridgeRegistry {
             await this.ensureHttpServer();
             this.routes.set(pathname, run);
             const address = this.getHttpServerAddress();
-            if (!address)
+            if (!address || !this.advertisedHost)
                 throw new Error("Cursor pi tool bridge HTTP server is not listening");
-            return `http://${LOOPBACK_HOST}:${address.port}${pathname}`;
+            return `http://${this.advertisedHost}:${address.port}${pathname}`;
         });
     }
     async unregisterRun(pathname, run) {
@@ -71,7 +123,7 @@ export class CursorPiToolBridgeRegistry {
         return result;
     }
     getHttpServerAddress() {
-        const address = asRecord(this.httpServer?.address());
+        const address = asRecord(this.httpServers[0]?.address());
         if (typeof address?.port !== "number")
             return undefined;
         return {
@@ -99,13 +151,17 @@ export class CursorPiToolBridgeRegistry {
     }
     async ensureHttpServer() {
         this.listenPromise ??= this.startHttpServer().catch((error) => {
-            this.httpServer = undefined;
+            this.httpServers = [];
+            this.advertisedHost = undefined;
             this.listenPromise = undefined;
             throw error;
         });
         await this.listenPromise;
     }
     async startHttpServer() {
+        // A hostname is a listener policy, not a mutable per-run URL preference.
+        const advertisedHost = resolveCursorPiToolBridgeUrlHost(this.env);
+        const range = resolveCursorPiToolBridgePortRange(this.env);
         const [{ getRequestListener }, { createMcpHonoApp }] = await Promise.all([
             import("@hono/node-server"),
             import("@modelcontextprotocol/hono"),
@@ -115,51 +171,45 @@ export class CursorPiToolBridgeRegistry {
             const parsedBody = context.get("parsedBody");
             return this.handleHttpRequest(context.req.raw, parsedBody);
         });
-        const server = createServer(getRequestListener(app.fetch, { overrideGlobalObjects: false }));
-        this.httpServer = server;
-        await new Promise((resolve, reject) => {
-            const onError = (error) => {
-                server.off("listening", onListening);
-                reject(error);
-            };
-            const onListening = () => {
-                server.off("error", onError);
-                resolve();
-            };
-            server.once("error", onError);
-            server.once("listening", onListening);
-            server.listen(0, LOOPBACK_HOST);
-        });
+        const listener = getRequestListener(app.fetch, { overrideGlobalObjects: false });
+        const attempts = range ? range.last - range.first + 1 : advertisedHost === "localhost" ? EPHEMERAL_BIND_ATTEMPTS : 1;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            const servers = [createServer(listener)];
+            try {
+                await listenOnce(servers[0], range ? range.first + attempt : 0);
+                if (advertisedHost === "localhost") {
+                    const port = servers[0].address().port;
+                    const ipv6 = createServer(listener);
+                    servers.push(ipv6);
+                    // Own both explicit loopbacks before publishing any tokenized URL.
+                    await listenOnce(ipv6, port, "::1");
+                }
+                this.httpServers = servers;
+                this.advertisedHost = advertisedHost;
+                return;
+            }
+            catch (error) {
+                try {
+                    await closeServers(servers);
+                }
+                catch {
+                    throw error;
+                } // Never retry or replace the bind failure when rollback fails.
+                if (error.code !== "EADDRINUSE" || (!range && advertisedHost !== "localhost"))
+                    throw error;
+            }
+        }
+        if (range)
+            throw new Error(`Cursor pi tool bridge could not listen on any port in ${range.first}-${range.last} (all in use)`);
+        throw new Error("Cursor pi tool bridge could not own both localhost loopback listeners on an ephemeral port");
     }
     async closeHttpServer() {
         await this.listenPromise?.catch(() => undefined);
-        const server = this.httpServer;
-        if (!server)
-            return;
-        this.httpServer = undefined;
+        const servers = this.httpServers;
+        this.httpServers = [];
+        this.advertisedHost = undefined;
         this.listenPromise = undefined;
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            let closeTimer;
-            const settle = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (closeTimer)
-                    clearTimeout(closeTimer);
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            };
-            closeTimer = setTimeout(() => settle(), HTTP_SERVER_CLOSE_GRACE_MS);
-            closeTimer.unref?.();
-            server.close((error) => {
-                settle(error ?? undefined);
-            });
-            server.closeIdleConnections();
-            server.closeAllConnections();
-        });
+        await closeServers(servers);
     }
     async handleHttpRequest(request, parsedBody) {
         const url = new URL(request.url);

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

@@ -1,5 +1,5 @@
 import { createMcpToolName, normalizeMcpInputSchema, stableNameHash } from "./cursor-pi-tool-bridge-mcp.js";
-export { CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV, CURSOR_PI_TOOL_BRIDGE_ENV, resolveCursorPiToolBridgeBuiltinsEnabled, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-env.js";
+export { CURSOR_PI_TOOL_BRIDGE_ENV, resolveCursorPiToolBridgeBuiltinsEnabled, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-env.js";
 import { isRegisteredCursorNativeToolName } from "./cursor-native-tool-display-state.js";
 import { isExcludedFromCursorBridgeExposure } from "./cursor-tool-presentation-registry.js";
 const OVERLAPPING_CURSOR_NATIVE_PI_BUILTIN_TOOL_NAMES = new Set(["read", "bash", "write", "edit", "grep", "find", "ls"]);

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

@@ -1,11 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV, CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX, serializeCursorPiToolBridgeDiagnostic, } from "./cursor-pi-tool-bridge-diagnostics.js";
-import { CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV, CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV, CURSOR_PI_TOOL_BRIDGE_ENV, } from "./cursor-pi-tool-bridge-env.js";
+import { CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX, serializeCursorPiToolBridgeDiagnostic, } from "./cursor-pi-tool-bridge-diagnostics.js";
 import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
-import { isCursorPiBridgeToolCallId, MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
-import { LOOPBACK_HOST, CursorPiToolBridgeRegistry } from "./cursor-pi-tool-bridge-server.js";
+import { isCursorPiBridgeToolCallId } from "./cursor-pi-tool-bridge-constants.js";
+import { CursorPiToolBridgeRegistry } from "./cursor-pi-tool-bridge-server.js";
 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 { 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();
@@ -110,13 +109,7 @@ export function getRegisteredCursorPiToolBridge(pi) {
     return pi ? bridges.get(pi) : registeredCursorPiToolBridge;
 }
 export const __testUtils = {
-    CURSOR_PI_TOOL_BRIDGE_ENV,
-    CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV,
-    CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV,
-    CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV,
     CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX,
-    LOOPBACK_HOST,
-    MCP_SERVER_NAME,
     createRegistry(pi, env = process.env) {
         return new CursorPiToolBridgeRegistry(pi, env);
     },
@@ -130,7 +123,6 @@ export const __testUtils = {
         return bridgeToolExecutionAbortTracker.getActiveCount();
     },
     buildWindowsBridgeBashAbortCommandForTests: buildWindowsBridgeBashAbortCommand,
-    installWindowsBridgeBashAbortMarkerForTests: installWindowsBridgeBashAbortMarker,
     emitBridgeToolExecutionProcessAbortSignalForTests(signal) {
         bridgeToolExecutionAbortTracker.emitProcessAbortSignalForTests(signal);
     },

package/dist/cursor-provider-errors.js

@@ -140,7 +140,7 @@ function isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence) {
         /\b(?:onStall|reportStall|StallDetected)\b/i.test(stackEvidence));
 }
 /**
- * @cursor/sdk@1.0.36 throws internal RetriableError (name/kind "RetriableError") with message
+ * @cursor/sdk@1.0.37 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.
  */
@@ -192,7 +192,7 @@ export function classifyCursorConnectError(error) {
     }
     const directAbort = (code === 1 || code === "canceled") &&
         (causeName === "AbortError" || /AbortError/.test(stack));
-    // The vendored 1.0.36 transport wraps a canceled ConnectError as Unknown.
+    // The vendored SDK transport can wrap a canceled ConnectError as Unknown.
     // Require the observed canceled -> AbortError cause chain, not generic text.
     const wrappedAbort = (code === 2 || code === "unknown") &&
         causeName === "ConnectError" &&
@@ -214,12 +214,6 @@ export function classifyCursorConnectError(error) {
     }
     return undefined;
 }
-export function isCursorSdkAbortConnectError(error) {
-    return classifyCursorConnectError(error)?.kind === "abort";
-}
-export function isUnauthenticatedConnectError(error) {
-    return classifyCursorConnectError(error)?.kind === "unauthenticated";
-}
 function isLikelyNetworkTimeout(message) {
     return (/\b(ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENETUNREACH|EAI_AGAIN|NGHTTP2_ENHANCE_YOUR_CALM|ERR_HTTP2_STREAM_ERROR|ERR_HTTP2_SESSION_ERROR)\b/i.test(message) ||
         /\bConnectError\b.*\b(unavailable|deadline|timeout|timed out)\b/i.test(message) ||

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

@@ -9,7 +9,7 @@ import { trimCurrentTurnAlreadyEmittedCursorText } from "./cursor-run-final-text
 import { formatCursorSdkAbortMessage, resolveCursorSdkAbortCause } from "./cursor-provider-errors.js";
 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;
+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;
@@ -36,7 +36,7 @@ export function createCursorNativeReplayId() {
 function getCursorNativeReplayIdFromToolCallId(toolCallId) {
     return CURSOR_NATIVE_REPLAY_TOOL_ID_PATTERN.exec(toolCallId)?.[1];
 }
-export function getPendingCursorLiveRun(context, scopeKey) {
+function getPendingCursorLiveRun(context, scopeKey) {
     return cursorLiveRuns.getPendingFromContext(context, getCursorNativeReplayIdFromToolCallId, scopeKey);
 }
 export function getActiveCursorLiveRunForCurrentScope(scopeKey) {
@@ -357,7 +357,7 @@ export async function drainCursorLiveRunTurn(stream, partial, model, context, ru
         });
     }
 }
-export async function drainExistingCursorLiveRunBeforeSend(stream, partial, model, context, signal, turnDebugRecorder, scopeKey, occupancyFloor) {
+export async function drainExistingCursorLiveRunBeforeSend(stream, partial, model, context, signal, turnDebugRecorder, scopeKey, occupancyFloor, nativeToolsEnabled = true) {
     turnDebugRecorder?.recordDrainEvent("pre_send_start", {});
     while (true) {
         const run = getPendingCursorLiveRun(context, scopeKey) ?? getActiveCursorLiveRunForCurrentScope(scopeKey);
@@ -369,6 +369,11 @@ export async function drainExistingCursorLiveRunBeforeSend(stream, partial, mode
             const outcome = await cursorLiveRuns.withRunLease(run, signal, async () => {
                 if (run.disposed)
                     return "continue_send";
+                // Check under the drain lease, before consuming/delivering Pi results:
+                // resolving a bridge waiter can resume the SDK's old tool surface.
+                if ((run.nativeToolsEnabled !== false) !== nativeToolsEnabled) {
+                    throw new Error("Cursor native tool policy changed while a local run is pending; restore the prior policy to finish it or run /cursor-abort before retrying. Already-executed work is not undone.");
+                }
                 const consumed = cursorLiveRuns.consumeToolResults(run, context, getCursorNativeReplayIdFromToolCallId);
                 await run.bridgeRun?.resolveToolResults(consumed.toolResults);
                 const shouldChainUserInput = run.chainUserInputAfterCompletion || hasTrailingUserMessagesAfterToolResults(context);

package/dist/cursor-provider-overflow.js

@@ -12,7 +12,7 @@ import { CURSOR_PROVIDER } from "./cursor-model.js";
  *
  * See pi `docs/custom-provider.md` -> "Context Overflow Errors".
  */
-export const CURSOR_OVERFLOW_MARKER = "context_length_exceeded";
+const CURSOR_OVERFLOW_MARKER = "context_length_exceeded";
 /**
  * Context-overflow phrases. These overlap pi's own `OVERFLOW_PATTERNS` so the
  * false-positive surface matches pi's built-in detection for other providers.
@@ -37,9 +37,9 @@ const CURSOR_THROTTLE_PATTERN = /too many requests|rate.?limit|throttl|retry.?af
  * Map a finalized Cursor assistant `errorMessage` to pi's overflow form.
  * Returns `undefined` when the message is not a Cursor context-overflow failure.
  *
- * Pure and idempotent so it is safe to call repeatedly and unit-test in isolation.
+ * Idempotent so repeated message delivery does not add another prefix.
  */
-export function normalizeCursorOverflowErrorMessage(errorMessage) {
+function normalizeCursorOverflowErrorMessage(errorMessage) {
     const message = errorMessage?.trim();
     if (!message)
         return undefined;
@@ -53,22 +53,6 @@ export function normalizeCursorOverflowErrorMessage(errorMessage) {
     }
     return undefined;
 }
-/**
- * Rewrite a finalized assistant message into pi's overflow form when it is a
- * Cursor context-overflow failure. Returns the replacement message (for the
- * `message_end` result) or `undefined` to leave it unchanged.
- *
- * `isCursorProvider` carries the provider scoping decision out of the handler so
- * the full logic is unit-testable without a pi event harness.
- */
-export function rewriteCursorOverflowAssistantMessage(message, isCursorProvider) {
-    if (!isCursorProvider || message.stopReason !== "error")
-        return undefined;
-    const rewritten = normalizeCursorOverflowErrorMessage(message.errorMessage);
-    if (!rewritten)
-        return undefined;
-    return { ...message, errorMessage: rewritten };
-}
 /**
  * Register a `message_end` handler that rewrites Cursor context-overflow
  * failures into the `context_length_exceeded` form pi auto-compacts on.
@@ -82,9 +66,11 @@ export function registerCursorOverflowNormalization(pi) {
         if (message.role !== "assistant")
             return undefined;
         const isCursorProvider = message.provider === CURSOR_PROVIDER || ctx.model?.provider === CURSOR_PROVIDER;
-        const rewritten = rewriteCursorOverflowAssistantMessage(message, isCursorProvider);
+        if (!isCursorProvider || message.stopReason !== "error")
+            return undefined;
+        const rewritten = normalizeCursorOverflowErrorMessage(message.errorMessage);
         if (!rewritten)
             return undefined;
-        return { message: rewritten };
+        return { message: { ...message, errorMessage: rewritten } };
     });
 }

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

@@ -24,6 +24,7 @@ import { MISSING_CURSOR_API_KEY_MESSAGE } from "./cursor-provider-errors.js";
 import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
 import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
+import { assertCursorNativeToolsRuntime } from "./cursor-native-tools.js";
 import { prepareCursorSummaryProviderTurn } from "./cursor-provider-turn-summary.js";
 function buildCursorCloudPromptContext(context, handoff, nativeSourceRoles) {
     if (handoff === "bootstrap")
@@ -182,7 +183,7 @@ async function prepareCursorCloudProviderTurn(prepareParams) {
     }
 }
 async function prepareCursorLocalProviderTurn(prepareParams) {
-    const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled, agents, customSubagentNames } = prepareParams;
+    const { params, cwd, resolvedApiKey, sdkEventDebug, throwIfAborted, resolvedConfig, agentMode, selection, fastEnabled, agents, customSubagentNames, nativeToolsEnabled } = prepareParams;
     const { model, context, options } = params;
     let restoreCursorSdkOutputFilter;
     let sessionAgentScopeKey;
@@ -212,6 +213,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
             settingSources,
             localSafety,
             agents,
+            nativeToolsEnabled,
             localResume: resolvedConfig.local.resume.value,
             storeRoot: resolvedConfig.local.storeRoot.value,
             useHttp1ForAgent,
@@ -236,6 +238,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
                 ...getCursorPromptOptions(model),
                 nativeSourceRoles: params.request.nativeSourceRoles,
                 agentMode,
+                nativeToolsEnabled,
                 includePiBridgeGuidance,
                 includePiAskQuestionGuidance: false,
             };
@@ -245,6 +248,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
             return {
                 ...promptOptions,
                 toolManifest: buildCursorToolManifestText({
+                    nativeToolsEnabled,
                     bridgeSnapshot: sessionAgentLease.bridgeRun?.snapshot,
                     piBridgeEnabled: resolveCursorPiToolBridgeEnabled(),
                     includePiBridgeGuidance,
@@ -295,6 +299,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
             agentMode,
             localForce: resolvedConfig.local.force.value,
             localResume: resolvedConfig.local.resume.value,
+            ...(nativeToolsEnabled ? {} : { nativeToolsEnabled: false, tools: ["mcp"] }),
             resumedAgent: sessionAgentLease.resumed,
             activeToolNames: activeToolNames ? [...activeToolNames] : [],
             sessionAgentScopeKey,
@@ -308,6 +313,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
             ? cursorLiveRuns.start({
                 id: useNativeToolReplay ? nativeReplayId : bridgeRun?.id ?? nativeReplayId,
                 agent,
+                nativeToolsEnabled,
                 bridgeRun,
                 sessionBridgeRun,
                 sessionAgentScopeKey,
@@ -387,6 +393,7 @@ async function prepareCursorLocalProviderTurn(prepareParams) {
 export async function prepareCursorProviderTurn(prepareParams) {
     const { params, resolvedConfig } = prepareParams;
     const { model, options } = params;
+    assertCursorNativeToolsRuntime(resolvedConfig.runtime.value, prepareParams.nativeToolsEnabled);
     const fastEnabled = resolvedConfig.runtime.value === "cloud" ? undefined : getEffectiveFastForModelId(model.id, params.scope.scopeKey);
     const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
     if (resolvedConfig.runtime.value === "local" && params.request.purpose !== "normal") {