pi-cursor-sdk 0.1.37 → 0.1.38

package/src/cursor-native-tool-display-tools.ts

@@ -10,11 +10,17 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import type { TSchema } from "typebox";
-import { getCursorSessionCwd } from "./cursor-session-cwd.js";
+import { getCursorSessionCwd } from "./cursor-session-scope.js";
 import {
-	CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
-	isCursorReplayToolName,
-} from "./cursor-tool-names.js";
+	BUILTIN_NATIVE_CURSOR_TOOL_NAMES,
+	CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES,
+	CURSOR_REPLAY_TOOL_NAMES,
+	isNativeCursorToolName,
+	NATIVE_CURSOR_TOOL_NAMES,
+	type BuiltinNativeCursorToolName,
+	type NativeCursorToolName,
+} from "./cursor-native-tool-names.js";
+import { isCursorReplayToolName } from "./cursor-tool-presentation-registry.js";
 import {
 	createCursorReplayOnlyToolDefinition,
 	isCursorReplayNativeEditDetails,
@@ -29,8 +35,6 @@ import {
 	isCursorReplayToolCallId,
 } from "./cursor-native-tool-display-state.js";
 
-const CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES = [CURSOR_REPLAY_ACTIVITY_TOOL_NAME] as const;
-const CURSOR_REPLAY_TOOL_NAMES = [CURSOR_REPLAY_ACTIVITY_TOOL_NAME] as const;
 
 type AnyToolDefinition = ToolDefinition<TSchema, unknown, unknown>;
 type RenderCall = NonNullable<AnyToolDefinition["renderCall"]>;
@@ -117,8 +121,6 @@ function renderWriteReplayResult(
 		: renderBase();
 }
 
-type BuiltinNativeCursorToolName = "read" | "bash" | "edit" | "write" | "grep" | "find" | "ls";
-
 const NATIVE_CURSOR_TOOL_STRATEGIES: Record<BuiltinNativeCursorToolName, NativeReplayStrategy> = {
 	read: {
 		createDefinition: (cwd) => createReadToolDefinition(cwd) as AnyToolDefinition,
@@ -145,12 +147,6 @@ const NATIVE_CURSOR_TOOL_STRATEGIES: Record<BuiltinNativeCursorToolName, NativeR
 	ls: { createDefinition: (cwd) => createLsToolDefinition(cwd) as AnyToolDefinition },
 };
 
-const BUILTIN_NATIVE_CURSOR_TOOL_NAMES = Object.keys(NATIVE_CURSOR_TOOL_STRATEGIES) as BuiltinNativeCursorToolName[];
-export const NATIVE_CURSOR_TOOL_NAMES = [
-	...BUILTIN_NATIVE_CURSOR_TOOL_NAMES,
-	...CURSOR_REPLAY_TOOL_NAMES,
-] as readonly NativeCursorToolName[];
-export type NativeCursorToolName = BuiltinNativeCursorToolName | typeof CURSOR_REPLAY_TOOL_NAMES[number];
 
 function getNativeReplayStrategy(toolName: string): NativeReplayStrategy | undefined {
 	return Object.hasOwn(NATIVE_CURSOR_TOOL_STRATEGIES, toolName)
@@ -158,9 +154,6 @@ function getNativeReplayStrategy(toolName: string): NativeReplayStrategy | undef
 		: undefined;
 }
 
-export function isNativeCursorToolName(toolName: string): toolName is NativeCursorToolName {
-	return NATIVE_CURSOR_TOOL_NAMES.some((nativeToolName) => nativeToolName === toolName);
-}
 
 export function wrapNativeCursorTool<TParams extends TSchema, TDetails, TState>(
 	definition: ToolDefinition<TParams, TDetails, TState>,

package/src/cursor-native-tool-names.ts

@@ -0,0 +1,16 @@
+import { CURSOR_REPLAY_ACTIVITY_TOOL_NAME } from "./cursor-tool-presentation-registry.js";
+
+export const CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES = [CURSOR_REPLAY_ACTIVITY_TOOL_NAME] as const;
+export const CURSOR_REPLAY_TOOL_NAMES = [CURSOR_REPLAY_ACTIVITY_TOOL_NAME] as const;
+export const BUILTIN_NATIVE_CURSOR_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"] as const;
+export const NATIVE_CURSOR_TOOL_NAMES = [
+	...BUILTIN_NATIVE_CURSOR_TOOL_NAMES,
+	...CURSOR_REPLAY_TOOL_NAMES,
+] as readonly NativeCursorToolName[];
+
+export type BuiltinNativeCursorToolName = typeof BUILTIN_NATIVE_CURSOR_TOOL_NAMES[number];
+export type NativeCursorToolName = BuiltinNativeCursorToolName | typeof CURSOR_REPLAY_TOOL_NAMES[number];
+
+export function isNativeCursorToolName(toolName: string): toolName is NativeCursorToolName {
+	return NATIVE_CURSOR_TOOL_NAMES.some((nativeToolName) => nativeToolName === toolName);
+}

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

@@ -0,0 +1,12 @@
+import { parseEnvBoolean } from "./cursor-env-boolean.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 function resolveCursorPiToolBridgeEnabled(env: Record<string, string | undefined> = process.env): boolean {
+	return parseEnvBoolean(env[CURSOR_PI_TOOL_BRIDGE_ENV], true);
+}
+
+export function resolveCursorPiToolBridgeBuiltinsEnabled(env: Record<string, string | undefined> = process.env): boolean {
+	return parseEnvBoolean(env[CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV], false);
+}

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

@@ -3,19 +3,17 @@ import type { Context, ToolResultMessage } from "@earendil-works/pi-ai";
 import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
 import { buildCursorPiBridgeMcpToolDescription, CURSOR_PI_BRIDGE_MCP_TOOL_PREFIX } from "./cursor-bridge-contract.js";
 import type { CursorPiBridgeToolDefinition, CursorPiMcpInputSchema } from "./cursor-pi-tool-bridge-types.js";
-import { getFirstStringByKeys } from "./cursor-record-utils.js";
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}
+import { asRecord, stringifyUnknown } from "./cursor-record-utils.js";
 
 export function normalizeMcpInputSchema(schema: unknown): CursorPiMcpInputSchema {
-	if (isRecord(schema) && schema.type === "object") return schema as CursorPiMcpInputSchema;
+	const record = asRecord(schema);
+	if (record?.type === "object") return record as CursorPiMcpInputSchema;
 	return { type: "object", properties: {} };
 }
 
 export function normalizeMcpArgs(args: unknown): Record<string, unknown> {
-	return isRecord(args) ? { ...args } : {};
+	const record = asRecord(args);
+	return record ? { ...record } : {};
 }
 
 export function waitForProtocolFlush(): Promise<void> {
@@ -73,21 +71,21 @@ export function snapshotToolToMcpTool(tool: CursorPiBridgeToolDefinition): Tool
 
 export function convertPiContentToMcpContent(content: unknown): CallToolResult["content"] {
 	if (!Array.isArray(content)) {
-		return [{ type: "text", text: typeof content === "string" ? content : JSON.stringify(content) }];
+		return [{ type: "text", text: stringifyUnknown(content) }];
 	}
 
 	const mcpContent: CallToolResult["content"] = [];
 	for (const block of content) {
-		if (!isRecord(block)) continue;
-		if (block.type === "text" && typeof block.text === "string") {
-			mcpContent.push({ type: "text", text: block.text });
+		const record = asRecord(block);
+		if (record?.type === "text" && typeof record.text === "string") {
+			mcpContent.push({ type: "text", text: record.text });
 			continue;
 		}
-		if (block.type === "image" && typeof block.data === "string" && typeof block.mimeType === "string") {
-			mcpContent.push({ type: "image", data: block.data, mimeType: block.mimeType });
+		if (record?.type === "image" && typeof record.data === "string" && typeof record.mimeType === "string") {
+			mcpContent.push({ type: "image", data: record.data, mimeType: record.mimeType });
 			continue;
 		}
-		mcpContent.push({ type: "text", text: JSON.stringify(block) });
+		mcpContent.push({ type: "text", text: stringifyUnknown(block) });
 	}
 
 	return mcpContent.length > 0 ? mcpContent : [{ type: "text", text: "" }];
@@ -97,22 +95,19 @@ export function asToolResultMessage(value: Context["messages"][number]): ToolRes
 	return value.role === "toolResult" ? value : undefined;
 }
 
-export function getStringField(record: Record<string, unknown>, fields: string[]): string | undefined {
-	return getFirstStringByKeys(record, fields, { nonEmpty: true });
-}
-
 export function containsKnownMcpToolName(value: unknown, knownMcpToolNames: ReadonlySet<string>, depth = 0): boolean {
 	if (depth > 4) return false;
 	if (Array.isArray(value)) return value.some((entry) => containsKnownMcpToolName(entry, knownMcpToolNames, depth + 1));
-	if (!isRecord(value)) return false;
+	const record = asRecord(value);
+	if (!record) return false;
 
 	for (const field of ["tool", "toolName", "name", "mcpToolName", "serverToolName"]) {
-		const fieldValue = value[field];
+		const fieldValue = record[field];
 		if (typeof fieldValue === "string" && knownMcpToolNames.has(fieldValue)) return true;
 	}
 
 	for (const nestedField of ["args", "arguments", "input"]) {
-		if (containsKnownMcpToolName(value[nestedField], knownMcpToolNames, depth + 1)) return true;
+		if (containsKnownMcpToolName(record[nestedField], knownMcpToolNames, depth + 1)) return true;
 	}
 
 	return false;

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

@@ -27,12 +27,11 @@ import {
 	asToolResultMessage,
 	containsKnownMcpToolName,
 	convertPiContentToMcpContent,
-	getStringField,
-	isRecord,
 	normalizeMcpArgs,
 	snapshotToolToMcpTool,
 	waitForProtocolFlush,
 } from "./cursor-pi-tool-bridge-mcp.js";
+import { asRecord, getFirstStringByKeys } from "./cursor-record-utils.js";
 
 export interface CursorPiToolBridgeRunHost {
 	registerRun(pathname: string, run: CursorPiToolBridgeRunImpl): Promise<string>;
@@ -178,12 +177,13 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 	}
 
 	isBridgeMcpToolCall(toolCall: unknown): boolean {
-		if (!isRecord(toolCall)) return false;
-		const toolName = getStringField(toolCall, ["name", "toolName", "mcpToolName"]);
+		const record = asRecord(toolCall);
+		if (!record) return false;
+		const toolName = getFirstStringByKeys(record, ["name", "toolName", "mcpToolName"], { nonEmpty: true });
 		if (toolName && this.knownMcpToolNames.has(toolName)) return true;
 
 		const isMcpEnvelope = toolName === "mcp" || toolName === MCP_SERVER_NAME;
-		const cursorMcpCallId = getStringField(toolCall, ["call_id", "callId", "id", "toolCallId", "requestId"]);
+		const cursorMcpCallId = getFirstStringByKeys(record, ["call_id", "callId", "id", "toolCallId", "requestId"], { nonEmpty: true });
 		if (cursorMcpCallId && this.knownCursorMcpCallIds.has(cursorMcpCallId) && isMcpEnvelope) return true;
 
 		if (containsKnownMcpToolName(toolCall, this.knownMcpToolNames)) return true;

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

@@ -6,7 +6,7 @@ import type {
 	CursorPiToolBridgeRunOptions,
 	CursorPiToolBridgeSnapshotApi,
 } from "./cursor-pi-tool-bridge-types.js";
-import { isRecord } from "./cursor-pi-tool-bridge-mcp.js";
+import { asRecord } from "./cursor-record-utils.js";
 import type { CursorPiToolBridgeRunImpl } from "./cursor-pi-tool-bridge-run.js";
 import {
 	buildCursorPiToolBridgeSnapshot,
@@ -84,8 +84,13 @@ export class CursorPiToolBridgeRegistry implements CursorPiToolBridge {
 	}
 
 	getHttpServerAddress(): AddressInfo | undefined {
-		const address = this.httpServer?.address();
-		return isRecord(address) && typeof address.port === "number" ? address as AddressInfo : undefined;
+		const address = asRecord(this.httpServer?.address());
+		if (typeof address?.port !== "number") return undefined;
+		return {
+			address: typeof address.address === "string" ? address.address : LOOPBACK_HOST,
+			family: typeof address.family === "string" ? address.family : "IPv4",
+			port: address.port,
+		};
 	}
 
 	getEndpointCount(): number {

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

@@ -4,13 +4,15 @@ import type {
 	CursorPiToolBridgeSnapshotApi,
 	CursorPiToolBridgeSnapshotOptions,
 } from "./cursor-pi-tool-bridge-types.js";
-import { parseEnvBoolean } from "./cursor-env-boolean.js";
 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";
 import { isRegisteredCursorNativeToolName } from "./cursor-native-tool-display-state.js";
-import { isExcludedFromCursorBridgeExposure } from "./cursor-tool-names.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";
+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"]);
 
@@ -22,14 +24,6 @@ export function createEmptySnapshot(): CursorPiToolBridgeSnapshot {
 	};
 }
 
-export function resolveCursorPiToolBridgeEnabled(env: Record<string, string | undefined> = process.env): boolean {
-	return parseEnvBoolean(env[CURSOR_PI_TOOL_BRIDGE_ENV], true);
-}
-
-export function resolveCursorPiToolBridgeBuiltinsEnabled(env: Record<string, string | undefined> = process.env): boolean {
-	return parseEnvBoolean(env[CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV], false);
-}
-
 function isOverlappingCursorNativePiToolName(toolName: string): boolean {
 	return OVERLAPPING_CURSOR_NATIVE_PI_BUILTIN_TOOL_NAMES.has(toolName);
 }

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

@@ -8,11 +8,7 @@ import {
 import {
 	CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV,
 	CURSOR_PI_TOOL_BRIDGE_ENV,
-	buildCursorPiToolBridgeSnapshot,
-	buildCursorPiToolBridgeSurfaceSignature,
-	resolveCursorPiToolBridgeBuiltinsEnabled,
-	resolveCursorPiToolBridgeEnabled,
-} from "./cursor-pi-tool-bridge-snapshot.js";
+} from "./cursor-pi-tool-bridge-env.js";
 import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
 import { MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
 import { LOOPBACK_HOST, CursorPiToolBridgeRegistry } from "./cursor-pi-tool-bridge-server.js";
@@ -37,10 +33,14 @@ export type {
 export type { CursorPiToolBridgeDiagnosticEvent } from "./cursor-pi-tool-bridge-diagnostics.js";
 export { resolveCursorPiToolBridgeDebugEnabled } from "./cursor-pi-tool-bridge-diagnostics.js";
 export {
-	buildCursorPiToolBridgeSnapshot,
-	buildCursorPiToolBridgeSurfaceSignature,
+	CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV,
+	CURSOR_PI_TOOL_BRIDGE_ENV,
 	resolveCursorPiToolBridgeBuiltinsEnabled,
 	resolveCursorPiToolBridgeEnabled,
+} from "./cursor-pi-tool-bridge-env.js";
+export {
+	buildCursorPiToolBridgeSnapshot,
+	buildCursorPiToolBridgeSurfaceSignature,
 } from "./cursor-pi-tool-bridge-snapshot.js";
 
 let registeredCursorPiToolBridge: CursorPiToolBridgeRegistry | undefined;

package/src/cursor-provider-lazy.ts

@@ -0,0 +1,51 @@
+import {
+	createAssistantMessageEventStream,
+	type Api,
+	type AssistantMessage,
+	type AssistantMessageEventStream,
+	type Context,
+	type Model,
+	type SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+
+function makeProviderLoadErrorMessage(model: Model<Api>, error: unknown): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "error",
+		timestamp: Date.now(),
+		errorMessage: `Failed to load Cursor provider runtime: ${error instanceof Error ? error.message : String(error)}`,
+	};
+}
+
+export function streamCursorLazy(
+	model: Model<Api>,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	const outer = createAssistantMessageEventStream();
+	queueMicrotask(async () => {
+		try {
+			const { streamCursor } = await import("./cursor-provider.js");
+			for await (const event of streamCursor(model, context, options)) {
+				outer.push(event);
+			}
+		} catch (error) {
+			const message = makeProviderLoadErrorMessage(model, error);
+			outer.push({ type: "error", reason: "error", error: message });
+			outer.end(message);
+		}
+	});
+	return outer;
+}

package/src/cursor-provider-live-run-drain.ts

@@ -17,7 +17,7 @@ import {
 	deleteCursorNativeToolDisplay,
 	recordCursorNativeToolDisplay,
 	type CursorNativeToolDisplayItem,
-} from "./cursor-native-tool-display.js";
+} from "./cursor-native-tool-display-state.js";
 import { type CursorPiBridgeToolRequest } from "./cursor-pi-tool-bridge.js";
 import { resetSessionCursorAgent } from "./cursor-session-agent.js";
 import { applyCursorApproximateUsage } from "./cursor-usage-accounting.js";

package/src/cursor-provider-run-finalizer.ts

@@ -1,6 +1,5 @@
 import type { AssistantMessage } from "@earendil-works/pi-ai";
-import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
-import { abandonSessionCursorAgent } from "./cursor-provider-live-run-drain.js";
+import { abandonSessionCursorAgent, cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import {
 	classifyCursorRunEmission,
 	getCursorRunAbortMessage,
@@ -12,7 +11,10 @@ import {
 	sanitizeCursorProviderError,
 } from "./cursor-provider-errors.js";
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
-import type { IncompleteCursorToolRunOutcomeInput } from "./cursor-incomplete-tool-visibility.js";
+import {
+	buildIncompleteCursorToolRunOutcome,
+	type IncompleteCursorToolRunOutcomeInput,
+} from "./cursor-incomplete-tool-visibility.js";
 import type { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import type { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
@@ -24,8 +26,6 @@ import type {
 } from "./cursor-provider-turn-types.js";
 import { applyCursorApproximateUsage } from "./cursor-usage-accounting.js";
 import { hasUsableText } from "./cursor-record-utils.js";
-import { buildIncompleteCursorToolRunOutcome } from "./cursor-incomplete-tool-visibility.js";
-
 export type CursorTurnTerminalEvent =
 	| {
 			kind: "direct";

package/src/cursor-provider-run-outcome.ts

@@ -10,7 +10,6 @@ import { hasUsableText } from "./cursor-record-utils.js";
 import {
 	buildIncompleteCursorToolRunOutcome,
 	type IncompleteCursorToolRunOutcome,
-	type IncompleteCursorToolRunOutcomeInput,
 } from "./cursor-incomplete-tool-visibility.js";
 
 /** Unified SDK wait() facts consumed by live and direct emission strategies. */

package/src/cursor-provider-turn-coordinator.ts

@@ -13,7 +13,7 @@ import {
 	type IncompleteCursorToolRunOutcome,
 } from "./cursor-incomplete-tool-visibility.js";
 import { getToolName } from "./cursor-transcript-utils.js";
-import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
+import { getNormalizedCursorToolName } from "./cursor-tool-visibility.js";
 import { buildCursorPiToolDisplay } from "./cursor-tool-transcript.js";
 import { getField } from "./cursor-record-utils.js";
 import { CursorTurnDisplayRouter } from "./cursor-provider-turn-display-router.js";
@@ -32,10 +32,6 @@ import {
 	getToolFingerprint,
 } from "./cursor-provider-turn-tool-ledger.js";
 
-function getNormalizedCursorToolName(toolCall: unknown): string {
-	return classifyCursorToolVisibility(toolCall).normalizedName;
-}
-
 export interface CursorSdkTurnCoordinatorOptions {
 	stream: AssistantMessageEventStream;
 	partial: AssistantMessage;
@@ -207,6 +203,9 @@ export class CursorSdkTurnCoordinator {
 				identity: resolution.identity,
 				source: resolution.source,
 			});
+			if (resolution.matchedStartedCallId && resolution.matchedStartedCallId !== update.callId) {
+				this.ledger.recordCompletedIdentity(`cursor-tool:${resolution.matchedStartedCallId}`);
+			}
 			return;
 		}
 		if (update.type === "shell-output-delta") {

package/src/cursor-provider-turn-display-router.ts

@@ -10,7 +10,11 @@ import {
 	type IncompleteCursorToolDiscardReason,
 } from "./cursor-incomplete-tool-visibility.js";
 import { scrubPiToolDisplay, scrubSensitiveText } from "./cursor-sensitive-text.js";
-import { buildCursorPiToolDisplay, formatCursorToolTranscript, getCursorCreatePlanText } from "./cursor-tool-transcript.js";
+import {
+	buildCursorPiToolDisplay,
+	formatCursorToolTranscript,
+	getCursorCreatePlanText,
+} from "./cursor-tool-transcript.js";
 import { getToolName } from "./cursor-transcript-utils.js";
 import type { CursorPartialContentEmitter } from "./cursor-partial-content-emitter.js";
 import type { CursorToolDisplaySource } from "./cursor-provider-turn-tool-ledger.js";

package/src/cursor-provider-turn-emit.ts

@@ -1,10 +1,10 @@
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import {
+	cursorLiveRuns,
 	drainCursorLiveRunTurn,
 	flushPendingCursorLiveRunTraceEventsToStream,
 	settleCursorLiveToolBatch,
 } from "./cursor-provider-live-run-drain.js";
-import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
 import {
 	buildIncompleteCursorToolRunOutcome,
 	type IncompleteCursorToolRunOutcomeInput,

package/src/cursor-provider-turn-lifecycle-emitter.ts

@@ -8,13 +8,9 @@ import {
 	formatCursorToolLifecycleProgressText,
 	isCursorToolLifecycleEligible,
 } from "./cursor-tool-lifecycle.js";
-import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
+import { getNormalizedCursorToolName } from "./cursor-tool-visibility.js";
 import { getStartedToolCallFingerprint } from "./cursor-provider-turn-tool-ledger.js";
 
-function getNormalizedCursorToolName(toolCall: unknown): string {
-	return classifyCursorToolVisibility(toolCall).normalizedName;
-}
-
 export interface CursorToolLifecycleEmitterOptions {
 	liveRun?: CursorLiveRun;
 	resolvedApiKey?: string;

package/src/cursor-provider-turn-prepare.ts

@@ -8,23 +8,27 @@ import {
 	resetSessionCursorAgent,
 } from "./cursor-session-agent.js";
 import type { CursorPiBridgeToolRequest } from "./cursor-pi-tool-bridge.js";
-import { estimateCursorPromptInputTokens, getCursorPromptOptions } from "./cursor-usage-accounting.js";
+import { estimateCursorPromptTokens } from "./context.js";
+import { getCursorPromptOptions } from "./cursor-usage-accounting.js";
 import { getActiveContextToolNames } from "./cursor-context-tools.js";
 import type { CursorLiveRun } from "./cursor-live-run-coordinator.js";
-import { abandonSessionCursorAgent, cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
-import { createCursorNativeReplayId } from "./cursor-provider-live-run-drain.js";
-import { getEffectiveCursorAgentMode, getEffectiveFastForModelId } from "./cursor-state.js";
+import {
+	abandonSessionCursorAgent,
+	createCursorNativeReplayId,
+	cursorLiveRuns,
+} from "./cursor-provider-live-run-drain.js";
+import { getCursorProviderAgentModeOrThrow, getEffectiveFastForModelId } from "./cursor-state.js";
 import { buildCursorModelSelection } from "./model-discovery.js";
 import { getEffectiveCursorSettingSources } from "./cursor-setting-sources.js";
-import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-snapshot.js";
+import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
 import {
 	buildCursorToolManifestText,
 	resolveCursorToolManifestEnabled,
 } from "./cursor-tool-manifest.js";
-import { isCursorNativeToolDisplayRuntimeEnabled } from "./cursor-native-tool-display.js";
+import { isCursorNativeToolDisplayRuntimeEnabled } from "./cursor-native-tool-display-state.js";
 import { MISSING_CURSOR_API_KEY_MESSAGE } from "./cursor-provider-errors.js";
 import { CursorSdkTurnCoordinator } from "./cursor-provider-turn-coordinator.js";
-import { resolveCursorApiKey } from "./cursor-provider-turn-api-key.js";
+import { resolveCursorApiKey } from "./cursor-api-key.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
 import type {
 	CursorProviderTurnPrepareResult,
@@ -53,7 +57,7 @@ export async function prepareCursorProviderTurn(
 
 	try {
 		const fastEnabled = getEffectiveFastForModelId(model.id);
-		const agentMode = getEffectiveCursorAgentMode();
+		const agentMode = getCursorProviderAgentModeOrThrow();
 		const selection = buildCursorModelSelection(model.id, options?.reasoning ?? "off", fastEnabled);
 		const settingSources = getEffectiveCursorSettingSources();
 		const { Agent } = await loadCursorSdk();
@@ -116,7 +120,7 @@ export async function prepareCursorProviderTurn(
 			images: prompt.images.length > 0 ? prompt.images : undefined,
 		};
 		const sessionBridgeRun = bridgeRun;
-		const promptInputTokens = estimateCursorPromptInputTokens(prompt, promptOptions);
+		const promptInputTokens = estimateCursorPromptTokens(prompt, promptOptions);
 		const useNativeToolReplay = isCursorNativeToolDisplayRuntimeEnabled();
 		const activeToolNames = getActiveContextToolNames(context);
 		sdkEventDebug?.recordProviderMeta({

package/src/cursor-provider-turn-runner.ts

@@ -1,6 +1,6 @@
 import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
 import { drainExistingCursorLiveRunBeforeSend } from "./cursor-provider-live-run-drain.js";
-import { getCursorSessionCwd } from "./cursor-session-cwd.js";
+import { getCursorSessionCwd } from "./cursor-session-scope.js";
 import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import { CursorSdkEventDebugSink } from "./cursor-sdk-event-debug.js";
 import { awaitFinalizeCursorRunOutcome } from "./cursor-provider-turn-finalize.js";
@@ -17,7 +17,6 @@ import type {
 	CursorProviderTurnSendResult,
 } from "./cursor-provider-turn-types.js";
 
-export { resolveCursorApiKey } from "./cursor-provider-turn-api-key.js";
 export type { CursorProviderTurnRunnerParams } from "./cursor-provider-turn-types.js";
 
 export class CursorProviderTurnRunner {
@@ -34,13 +33,6 @@ export class CursorProviderTurnRunner {
 		if (this.options?.signal?.aborted) throw new CursorLiveRunAbortError();
 	}
 
-	private discardIncompleteTools(
-		prepared: CursorProviderTurnPrepareResult | undefined,
-		outcome: import("./cursor-incomplete-tool-visibility.js").IncompleteCursorToolRunOutcomeInput,
-	): void {
-		discardIncompleteToolsFromPrepared(prepared, outcome);
-	}
-
 	async run(sdkProcessErrorGuard: ReturnType<typeof installCursorSdkProcessErrorGuard>): Promise<void> {
 		const { stream, partial, model, context, options, sdkEventDebugRef } = this.params;
 		let prepared: CursorProviderTurnPrepareResult | undefined;
@@ -94,13 +86,13 @@ export class CursorProviderTurnRunner {
 					send,
 					prepared,
 					modelId: model.id,
-					discardIncompleteTools: (outcome) => this.discardIncompleteTools(prepared, outcome),
+					discardIncompleteTools: (outcome) => discardIncompleteToolsFromPrepared(prepared, outcome),
 				});
 				await emitCursorLiveTurn({
 					params: this.params,
 					prepared,
 					sdkEventDebug: this.sdkEventDebug,
-					discardIncompleteTools: (outcome) => this.discardIncompleteTools(prepared, outcome),
+					discardIncompleteTools: (outcome) => discardIncompleteToolsFromPrepared(prepared, outcome),
 				});
 				return;
 			}

package/src/cursor-provider-turn-sdk-normalizer.ts

@@ -1,4 +1,4 @@
-import { mergeCursorToolCalls } from "./cursor-tool-transcript.js";
+import { asRecord } from "./cursor-record-utils.js";
 import type { CursorLiveRun } from "./cursor-live-run-coordinator.js";
 import {
 	mergeShellOutputDeltasIntoCursorToolCall,
@@ -8,6 +8,22 @@ import type { CursorToolCompletionLedger } from "./cursor-provider-turn-tool-led
 
 export type CursorToolCompletionSource = "delta" | "step";
 
+function mergeCursorToolCalls(startedToolCall: unknown, completedToolCall: unknown): unknown {
+	const started = asRecord(startedToolCall);
+	const completed = asRecord(completedToolCall);
+	if (!started) return completedToolCall;
+	if (!completed) return startedToolCall;
+	return {
+		...started,
+		...completed,
+		name: completed.name ?? started.name,
+		type: completed.type ?? started.type,
+		args: completed.args ?? started.args,
+		input: completed.input ?? started.input,
+		result: completed.result ?? started.result,
+	};
+}
+
 export type ToolCompletionResolution =
 	| { action: "ignore-bridge"; identity?: string }
 	| {
@@ -47,15 +63,22 @@ export function resolveCursorToolCompletion(options: ResolveCursorToolCompletion
 		const callId = options.callId;
 		identity = typeof callId === "string" ? `cursor-tool:${callId}` : undefined;
 		resolvedToolCall = mergeCursorToolCalls(options.startedToolCall, options.toolCall);
-		if (typeof callId === "string") {
+		if (typeof callId === "string" && options.ledger.hasStartedToolCall(callId)) {
 			options.onClearStartedCallId?.(callId);
 			options.ledger.clearStartedToolCall(callId);
+		} else {
+			matchedStartedCallId = options.ledger.removeStartedToolCallForStep(options.toolCall, callId);
+			if (matchedStartedCallId) options.onClearStartedCallId?.(matchedStartedCallId);
 		}
 		resolvedToolCall = mergeShellOutputDeltasIntoCursorToolCall(
 			resolvedToolCall,
-			typeof callId === "string" ? options.shellOutput.takeDeltasForCall(callId) : undefined,
+			matchedStartedCallId
+				? options.shellOutput.takeDeltasForCall(matchedStartedCallId)
+				: typeof callId === "string"
+					? options.shellOutput.takeDeltasForCall(callId)
+					: undefined,
 		);
-		source = identity ? "started" : "fallback";
+		source = identity || matchedStartedCallId ? "started" : "fallback";
 	} else {
 		matchedStartedCallId = options.ledger.removeStartedToolCallForStep(options.toolCall, options.callId);
 		if (matchedStartedCallId) {
@@ -77,7 +100,7 @@ export function resolveCursorToolCompletion(options: ResolveCursorToolCompletion
 	}
 
 	if (options.source === "delta") {
-		return { action: "handle", toolCall: resolvedToolCall, identity, source };
+		return { action: "handle", toolCall: resolvedToolCall, identity, source, matchedStartedCallId };
 	}
 	return {
 		action: "handle",