pi-cursor-sdk 0.5.0 → 0.5.3

package/src/cursor-fallback-models.generated.ts

@@ -1,6 +1,6 @@
 import type { ModelListItem } from "@cursor/sdk";
 
-// Generated with @cursor/sdk@1.0.32 from 45 Cursor models.
+// Generated with @cursor/sdk@1.0.37 from 46 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 = [
@@ -913,6 +913,407 @@ export const FALLBACK_MODEL_ITEMS = [
 			}
 		]
 	},
+	{
+		id: "claude-haiku-5-5",
+		displayName: "Claude Haiku 5.5",
+		parameters: [
+			{
+				id: "thinking",
+				displayName: "Thinking",
+				values: [
+					{
+						value: "false"
+					},
+					{
+						value: "true"
+					}
+				]
+			},
+			{
+				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: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "low"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Low No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "medium"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Medium No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "high"
+					}
+				],
+				displayName: "Claude Haiku 5.5  High No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "xhigh"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Extra High No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "max"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Max No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "low"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Low No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "medium"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Medium No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "high"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M High No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "xhigh"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Extra High No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "false"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "max"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Max No Thinking"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "low"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Low"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "medium"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Medium"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "high"
+					}
+				],
+				displayName: "Claude Haiku 5.5  High"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "xhigh"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Extra High"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "300k"
+					},
+					{
+						id: "reasoning_effort",
+						value: "max"
+					}
+				],
+				displayName: "Claude Haiku 5.5  Max"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "low"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Low"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "medium"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Medium"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "high"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M High",
+				isDefault: true
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "xhigh"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Extra High"
+			},
+			{
+				params: [
+					{
+						id: "thinking",
+						value: "true"
+					},
+					{
+						id: "context",
+						value: "1m"
+					},
+					{
+						id: "reasoning_effort",
+						value: "max"
+					}
+				],
+				displayName: "Claude Haiku 5.5 1M Max"
+			}
+		]
+	},
 	{
 		id: "claude-opus-4-5",
 		displayName: "Claude Opus 4.5",

package/src/cursor-fallback-warning.ts

@@ -8,15 +8,19 @@ export type CursorFallbackWarningExtensionApi = CursorModelLifecycleExtensionApi
 
 export function registerCursorFallbackIssueWarning(
 	pi: CursorFallbackWarningExtensionApi,
-	issue: CursorModelFallbackIssue,
-): void {
+): (nextIssue: CursorModelFallbackIssue | undefined) => void {
+	let issue: CursorModelFallbackIssue | undefined;
 	const warnedSessionScopeKeys = new Set<string>();
 
 	registerCursorModelLifecycle(pi, (ctx: ExtensionContext) => {
-		if (!isCursorModel(ctx.model) || !ctx.hasUI) return;
+		if (!issue || !isCursorModel(ctx.model) || !ctx.hasUI) return;
 		const scopeKey = cursorSessionScopeKeyForManager(ctx.sessionManager);
 		if (warnedSessionScopeKeys.has(scopeKey)) return;
 		warnedSessionScopeKeys.add(scopeKey);
 		ctx.ui.notify(issue.message, "warning");
 	});
+	return (nextIssue) => {
+		if (nextIssue?.reason !== issue?.reason || nextIssue?.message !== issue?.message) warnedSessionScopeKeys.clear();
+		issue = nextIssue;
+	};
 }

package/src/cursor-live-run-coordinator.ts

@@ -153,6 +153,7 @@ interface CursorLiveRunPrivateState {
 	waiters: Set<ProgressWaiter>;
 	idleDisposeTimer?: ReturnType<typeof setTimeout>;
 	idleDisposeRequested: boolean;
+	pendingCallUnsubscribers?: Array<() => void>;
 	leased: boolean;
 	leaseQueue: LeaseWaiter[];
 	releasing?: Promise<void>;
@@ -313,6 +314,12 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				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;
@@ -492,9 +499,15 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 			const state = getPrivateState(run);
 			clearIdleDisposeTimer(run);
 			state.idleDisposeRequested = true;
-			if (state.leased || state.leaseQueue.length > 0) return;
-			state.idleDisposeRequested = false;
+			if (state.leased || state.leaseQueue.length > 0 ||
+				[run.bridgeRun, run.sessionBridgeRun].some((bridge) => bridge?.hasPendingToolCalls())) return;
 			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.
 				});
@@ -509,6 +522,12 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 				if (run.disposed) 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;

package/src/cursor-local-agent-ownership.ts

@@ -0,0 +1,18 @@
+import type { CursorSessionStoreIdentity } from "./cursor-session-store.js";
+
+// ponytail: process-local claims protect extension-owned handles and cleanup.
+// Cross-process SDK ownership requires an upstream store/agent lease contract.
+// Unproven disposal retains the exact handle claim until process exit.
+const claims = new Set<string>();
+
+export function claimCursorLocalAgent(identity: CursorSessionStoreIdentity, agentId: string): (() => void) | undefined {
+	const key = JSON.stringify([identity.stateRoot, agentId]);
+	if (claims.has(key)) return undefined;
+	claims.add(key);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		claims.delete(key);
+	};
+}

package/src/cursor-mcp-timeout-override.ts

@@ -91,7 +91,9 @@ export function isCursorSdkMcpToolTimeoutStack(stack: string | undefined): boole
 
 export function isCursorSdkMcpConnectTimeoutStack(stack: string | undefined): boolean {
 	if (!stack || !isCursorSdkMcpProtocolTimeoutStack(stack)) return false;
-	return /\bClient\.(?:connect|listTools)\b|\bMcpSdkClient\.getTools\b/.test(stack);
+	// 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);
 }
 
 function isCursorSdkDefaultMcpTimeout(delay: SetTimeoutDelay): boolean {

package/src/cursor-pi-tool-bridge-diagnostics.ts

@@ -49,6 +49,17 @@ interface CursorPiToolBridgeRunDisposedDiagnostic extends CursorPiToolBridgeLife
 	event: "run_disposed";
 }
 
+interface CursorPiToolBridgeMcpInitializedDiagnostic {
+	event: "mcp_initialized";
+	runId: string;
+}
+
+interface CursorPiToolBridgeMcpToolsListDiagnostic {
+	event: "mcp_tools_list";
+	runId: string;
+	toolCount: number;
+}
+
 export interface CursorPiToolBridgeRequestDiagnosticFields {
 	runId: string;
 	bridgeCallId: string;
@@ -79,6 +90,8 @@ export type CursorPiToolBridgeDiagnosticEvent =
 	| CursorPiToolBridgeToolsExposedDiagnostic
 	| CursorPiToolBridgeRunCancelledDiagnostic
 	| CursorPiToolBridgeRunDisposedDiagnostic
+	| CursorPiToolBridgeMcpInitializedDiagnostic
+	| CursorPiToolBridgeMcpToolsListDiagnostic
 	| CursorPiToolBridgeRequestQueuedDiagnostic
 	| CursorPiToolBridgeRequestResolvedDiagnostic
 	| CursorPiToolBridgeRequestRejectedDiagnostic;
@@ -89,6 +102,10 @@ function assertNeverDiagnosticEvent(_event: never): never {
 
 export function serializeCursorPiToolBridgeDiagnostic(event: CursorPiToolBridgeDiagnosticEvent): Record<string, unknown> {
 	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/src/cursor-pi-tool-bridge-run.ts

@@ -67,6 +67,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 	private readonly knownMcpToolNames: ReadonlySet<string>;
 	private readonly knownCursorMcpCallIds = new Set<string>();
 	private readonly queuedRequests: CursorPiBridgeToolRequest[] = [];
+	private readonly pendingToolCallListeners = new Set<() => void>();
 	private readonly pendingByPiToolCallId = new Map<string, PendingBridgeCall>();
 	private readonly pendingByBridgeCallId = new Map<string, PendingBridgeCall>();
 	private readonly pendingByCursorMcpCallId = new Map<string, PendingBridgeCall>();
@@ -190,6 +191,23 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		return this.pendingByPiToolCallId.has(piToolCallId);
 	}
 
+	hasPendingToolCalls(): boolean {
+		return this.pendingCount() > 0;
+	}
+
+	onPendingToolCallsChanged(listener: () => void): () => void {
+		this.pendingToolCallListeners.add(listener);
+		return () => { this.pendingToolCallListeners.delete(listener); };
+	}
+
+	private notifyPendingToolCallsChanged(): void {
+		for (const listener of this.pendingToolCallListeners) {
+			try { listener(); } catch {
+				// Observers must not prevent call registration or protocol settlement.
+			}
+		}
+	}
+
 	cancelPendingPiToolCallId(piToolCallId: string, reason: string): boolean {
 		const pending = this.pendingByPiToolCallId.get(piToolCallId);
 		if (!pending) return false;
@@ -234,6 +252,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		if (this.disposed) return;
 		this.disposed = true;
 		this.cancel("Cursor pi tool bridge run disposed");
+		this.pendingToolCallListeners.clear();
 		await waitForProtocolFlush();
 		await Promise.allSettled([
 			this.mcpTransport?.close(),
@@ -255,9 +274,16 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 			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,
@@ -315,6 +341,7 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 			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));
@@ -438,5 +465,6 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		if (pending.request.cursorMcpCallId) this.pendingByCursorMcpCallId.delete(pending.request.cursorMcpCallId);
 		const queuedIndex = this.queuedRequests.findIndex((request) => request.bridgeCallId === pending.request.bridgeCallId);
 		if (queuedIndex >= 0) this.queuedRequests.splice(queuedIndex, 1);
+		this.notifyPendingToolCallsChanged();
 	}
 }

package/src/cursor-pi-tool-bridge-server.ts

@@ -7,7 +7,7 @@ import type {
 	CursorPiToolBridgeSnapshotApi,
 } from "./cursor-pi-tool-bridge-types.js";
 import { asRecord } from "./cursor-record-utils.js";
-import type { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
+import { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
 import {
 	buildCursorPiToolBridgeSnapshot,
 	buildCursorPiToolBridgeSurfaceSignature,
@@ -55,7 +55,6 @@ export class CursorPiToolBridgeRegistry implements CursorPiToolBridge {
 				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/src/cursor-pi-tool-bridge-types.ts

@@ -60,6 +60,9 @@ export interface CursorPiToolBridgeRun {
 	resolveToolResults(toolResults: readonly ToolResultMessage[]): Promise<void>;
 	resolveToolResultsFromContext(context: Context): Promise<void>;
 	hasPendingPiToolCallId(piToolCallId: string): boolean;
+	hasPendingToolCalls(): boolean;
+	/** Synchronous changes; observer errors cannot affect settlement. Returns an idempotent unsubscribe. */
+	onPendingToolCallsChanged(listener: () => void): () => void;
 	isBridgeMcpToolCall(toolCall: unknown): boolean;
 	setOnToolRequest(handler?: (request: CursorPiBridgeToolRequest) => void): void;
 	setDebugRecorder(recorder?: CursorSdkEventDebugRecorder): void;