pi-cursor-sdk 0.4.0 → 0.5.0

package/dist/cursor-fallback-models.generated.js

@@ -1,4 +1,4 @@
-// Generated with @cursor/sdk@1.0.32 from 42 Cursor models.
+// Generated with @cursor/sdk@1.0.32 from 45 Cursor models.
 // Refresh with: npm run refresh:cursor-snapshots -- --write
 // Do not add secrets; this file stores public model metadata only.
 export const FALLBACK_MODEL_ITEMS = [
@@ -5597,6 +5597,185 @@ export const FALLBACK_MODEL_ITEMS = [
             }
         ]
     },
+    {
+        id: "claude-sonnet-5-5",
+        displayName: "Claude Sonnet 5.5",
+        parameters: [
+            {
+                id: "context",
+                displayName: "Context",
+                values: [
+                    {
+                        value: "300k",
+                        displayName: "300K"
+                    },
+                    {
+                        value: "1m",
+                        displayName: "1M"
+                    }
+                ]
+            },
+            {
+                id: "reasoning_effort",
+                displayName: "Effort",
+                values: [
+                    {
+                        value: "low",
+                        displayName: "Low"
+                    },
+                    {
+                        value: "medium",
+                        displayName: "Medium"
+                    },
+                    {
+                        value: "high",
+                        displayName: "High"
+                    },
+                    {
+                        value: "xhigh",
+                        displayName: "Extra High"
+                    },
+                    {
+                        value: "max",
+                        displayName: "Max"
+                    }
+                ]
+            }
+        ],
+        variants: [
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "300k"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "low"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5  Low"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "300k"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "medium"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5  Medium"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "300k"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "high"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5  High"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "300k"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "xhigh"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5  Extra High"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "300k"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "max"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5  Max"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "1m"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "low"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5 1M Low"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "1m"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "medium"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5 1M Medium"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "1m"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "high"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5 1M High",
+                isDefault: true
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "1m"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "xhigh"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5 1M Extra High"
+            },
+            {
+                params: [
+                    {
+                        id: "context",
+                        value: "1m"
+                    },
+                    {
+                        id: "reasoning_effort",
+                        value: "max"
+                    }
+                ],
+                displayName: "Claude Sonnet 5.5 1M Max"
+            }
+        ]
+    },
     {
         id: "composer-2",
         displayName: "Composer 2",
@@ -5977,6 +6156,114 @@ export const FALLBACK_MODEL_ITEMS = [
             }
         ]
     },
+    {
+        id: "glm-5p3",
+        displayName: "GLM 5.3",
+        parameters: [
+            {
+                id: "reasoning",
+                displayName: "Reasoning",
+                values: [
+                    {
+                        value: "low",
+                        displayName: "Low"
+                    },
+                    {
+                        value: "high",
+                        displayName: "High"
+                    },
+                    {
+                        value: "max",
+                        displayName: "Max"
+                    }
+                ]
+            }
+        ],
+        variants: [
+            {
+                params: [
+                    {
+                        id: "reasoning",
+                        value: "low"
+                    }
+                ],
+                displayName: "GLM 5.3 Low"
+            },
+            {
+                params: [
+                    {
+                        id: "reasoning",
+                        value: "high"
+                    }
+                ],
+                displayName: "GLM 5.3 High"
+            },
+            {
+                params: [
+                    {
+                        id: "reasoning",
+                        value: "max"
+                    }
+                ],
+                displayName: "GLM 5.3 Max",
+                isDefault: true
+            }
+        ]
+    },
+    {
+        id: "glm-5p3-flash",
+        displayName: "GLM 5.3 Flash",
+        parameters: [
+            {
+                id: "reasoning",
+                displayName: "Reasoning",
+                values: [
+                    {
+                        value: "low",
+                        displayName: "Low"
+                    },
+                    {
+                        value: "high",
+                        displayName: "High"
+                    },
+                    {
+                        value: "max",
+                        displayName: "Max"
+                    }
+                ]
+            }
+        ],
+        variants: [
+            {
+                params: [
+                    {
+                        id: "reasoning",
+                        value: "low"
+                    }
+                ],
+                displayName: "GLM 5.3 Flash Low"
+            },
+            {
+                params: [
+                    {
+                        id: "reasoning",
+                        value: "high"
+                    }
+                ],
+                displayName: "GLM 5.3 Flash High"
+            },
+            {
+                params: [
+                    {
+                        id: "reasoning",
+                        value: "max"
+                    }
+                ],
+                displayName: "GLM 5.3 Flash Max",
+                isDefault: true
+            }
+        ]
+    },
     {
         id: "gpt-5-mini",
         displayName: "GPT-5 Mini",

package/dist/cursor-fallback-warning.js

@@ -1,12 +1,12 @@
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle } from "./cursor-model-lifecycle.js";
-import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { cursorSessionScopeKeyForManager } from "./cursor-session-scope.js";
 export function registerCursorFallbackIssueWarning(pi, issue) {
     const warnedSessionScopeKeys = new Set();
     registerCursorModelLifecycle(pi, (ctx) => {
         if (!isCursorModel(ctx.model) || !ctx.hasUI)
             return;
-        const scopeKey = getCursorSessionScopeKey();
+        const scopeKey = cursorSessionScopeKeyForManager(ctx.sessionManager);
         if (warnedSessionScopeKeys.has(scopeKey))
             return;
         warnedSessionScopeKeys.add(scopeKey);

package/dist/cursor-http1.js

@@ -1,19 +1,19 @@
 import { asRecord } from "./cursor-record-utils.js";
+import { getCursorSessionSettings } from "./cursor-session-settings.js";
 export const CURSOR_HTTP1_ENTRY_TYPE = "cursor-http1-state";
-let sessionCursorHttp1Enabled;
 let globalPreferenceAuthoritative = false;
 let configuredCursor;
 export function isCursorHttp1EntryData(value) {
     return typeof asRecord(value)?.enabled === "boolean";
 }
-export function getStoredCursorHttp1Enabled() {
-    return sessionCursorHttp1Enabled;
+export function getStoredCursorHttp1Enabled(scopeKey) {
+    return getCursorSessionSettings(scopeKey).http1;
 }
-export function setStoredCursorHttp1Enabled(enabled) {
-    sessionCursorHttp1Enabled = enabled;
+export function setStoredCursorHttp1Enabled(enabled, scopeKey) {
+    getCursorSessionSettings(scopeKey).http1 = enabled;
 }
-export function getResolvedSessionCursorHttp1Enabled() {
-    return globalPreferenceAuthoritative ? undefined : sessionCursorHttp1Enabled;
+export function getResolvedSessionCursorHttp1Enabled(scopeKey) {
+    return globalPreferenceAuthoritative ? undefined : getStoredCursorHttp1Enabled(scopeKey);
 }
 export function setCursorHttp1GlobalPreferenceAuthoritative(authoritative) {
     globalPreferenceAuthoritative = authoritative;
@@ -38,7 +38,7 @@ export function configureCursorSdkHttp1(sdk, setting) {
 }
 export const __testUtils = {
     reset() {
-        sessionCursorHttp1Enabled = undefined;
+        setStoredCursorHttp1Enabled(undefined);
         globalPreferenceAuthoritative = false;
         configuredCursor = undefined;
     },

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 ?? [],
@@ -270,7 +271,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 +284,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;
         },
@@ -389,12 +383,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-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();
     },
 };