pi-cursor-sdk 0.2.0 → 0.3.7

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

@@ -0,0 +1,146 @@
+import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
+import { drainExistingCursorLiveRunBeforeSend } from "./cursor-provider-live-run-drain.js";
+import { invalidateSessionAgent } from "./cursor-session-agent.js";
+import { getCursorSessionCwd, getCursorSessionScopeKey } 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";
+import { discardIncompleteToolsFromPrepared, emitCursorLiveTurn, } from "./cursor-provider-turn-emit.js";
+import { CursorRunFinalizer } from "./cursor-provider-run-finalizer.js";
+import { prepareCursorProviderTurn, requireCursorApiKey, resolveCursorProviderTurnConfig, } from "./cursor-provider-turn-prepare.js";
+import { sendCursorProviderTurn } from "./cursor-provider-turn-send.js";
+function requireLocalLivePreparedTurn(prepared) {
+    if (prepared.runtimeTarget !== "local" || prepared.runtime.kind !== "live") {
+        throw new Error("Cursor live run requires a local live prepared turn");
+    }
+    return prepared;
+}
+export class CursorProviderTurnRunner {
+    params;
+    sdkEventDebug;
+    resolvedApiKey;
+    runtimeTarget;
+    constructor(params) {
+        this.params = params;
+    }
+    get options() {
+        return this.params.options;
+    }
+    throwIfAborted() {
+        if (this.options?.signal?.aborted)
+            throw new CursorLiveRunAbortError();
+    }
+    async run(sdkProcessErrorGuard) {
+        const { stream, partial, model, context, options, sdkEventDebugRef } = this.params;
+        let prepared;
+        let sendResult;
+        let liveCompletion;
+        const runFinalizer = new CursorRunFinalizer({
+            runnerParams: this.params,
+            sdkEventDebug: () => this.sdkEventDebug,
+            sdkProcessErrorGuard,
+            resolvedApiKey: () => this.resolvedApiKey,
+            runtimeTarget: () => this.runtimeTarget,
+        });
+        try {
+            this.throwIfAborted();
+            const cwd = getCursorSessionCwd();
+            this.sdkEventDebug = CursorSdkEventDebugSink.maybeCreate({
+                cwd,
+                modelId: model.id,
+                provider: model.provider,
+            });
+            sdkEventDebugRef.current = this.sdkEventDebug;
+            this.sdkEventDebug?.recordContextSnapshot(context);
+            // Resolved once here, before any drain await, so the drain decision and the
+            // prepare dispatch below always act on the same config snapshot.
+            const resolvedConfig = resolveCursorProviderTurnConfig(cwd);
+            this.runtimeTarget = resolvedConfig.runtime.value;
+            if (resolvedConfig.runtime.value === "local") {
+                // The observed local-executor closed-pipe EPIPE is contained only from this
+                // turn's pre-send live-run drain through run completion; for live runs the
+                // finalizer holds the guard until run.wait() settles. A hit marks
+                // this scope's pooled agent transport dead so the next acquire recreates it.
+                const localScopeKey = getCursorSessionScopeKey();
+                sdkProcessErrorGuard.containLocalTransportClosedPipe(() => invalidateSessionAgent(localScopeKey, { deadTransport: true }));
+                if ((await drainExistingCursorLiveRunBeforeSend(stream, partial, model, context, options?.signal, this.sdkEventDebug)) ===
+                    "stream_ended") {
+                    return;
+                }
+            }
+            this.throwIfAborted();
+            this.resolvedApiKey = requireCursorApiKey(options);
+            prepared = await prepareCursorProviderTurn({
+                params: this.params,
+                cwd,
+                resolvedApiKey: this.resolvedApiKey,
+                sdkEventDebug: this.sdkEventDebug,
+                throwIfAborted: () => this.throwIfAborted(),
+                resolvedConfig,
+            });
+            sendResult = await sendCursorProviderTurn({
+                params: this.params,
+                prepared,
+                sdkEventDebug: this.sdkEventDebug,
+                sdkProcessErrorGuard,
+                throwIfAborted: () => this.throwIfAborted(),
+                resolvedApiKey: this.resolvedApiKey,
+            });
+            const { send } = sendResult;
+            if (prepared.runtime.kind === "live") {
+                const livePrepared = requireLocalLivePreparedTurn(prepared);
+                liveCompletion = runFinalizer.startLiveRunCompletion({
+                    send,
+                    prepared: livePrepared,
+                    modelId: model.id,
+                    discardIncompleteTools: (outcome) => discardIncompleteToolsFromPrepared(livePrepared, outcome),
+                });
+                await emitCursorLiveTurn({
+                    params: this.params,
+                    prepared: livePrepared,
+                    sdkEventDebug: this.sdkEventDebug,
+                    discardIncompleteTools: (outcome) => discardIncompleteToolsFromPrepared(livePrepared, outcome),
+                });
+                return;
+            }
+            const outcomePromise = awaitFinalizeCursorRunOutcome({
+                run: send.run,
+                prepared,
+                cursorAgentMessageOffset: send.cursorAgentMessageOffset,
+                modelId: model.id,
+                signal: options?.signal,
+                runResultFallback: send.run.result,
+                runErrorFallback: send.run.error,
+                resolvedApiKey: this.resolvedApiKey,
+                optionsApiKey: options?.apiKey,
+                sdkEventDebug: this.sdkEventDebug,
+                contextWindowAgentId: prepared.contextWindowAgentId,
+            });
+            prepared.lifecycle.trackRunCompletion(outcomePromise);
+            const finalized = await outcomePromise;
+            await runFinalizer.applyTerminalEvent({
+                kind: "direct",
+                prepared,
+                outcome: finalized.outcome,
+                displayOnlyTraceBlock: finalized.displayOnlyTraceBlock,
+            });
+        }
+        catch (error) {
+            await runFinalizer.applyTerminalEvent({ kind: "error", prepared, error });
+        }
+        finally {
+            await runFinalizer.cleanup(prepared, sendResult, liveCompletion);
+        }
+    }
+    async handleOuterCatch(error) {
+        const runFinalizer = new CursorRunFinalizer({
+            runnerParams: this.params,
+            sdkEventDebug: () => this.sdkEventDebug,
+            sdkProcessErrorGuard: installCursorSdkProcessErrorGuard(),
+            resolvedApiKey: () => this.resolvedApiKey,
+            runtimeTarget: () => this.runtimeTarget,
+        });
+        await runFinalizer.applyTerminalEvent({ kind: "error", prepared: undefined, error });
+        await runFinalizer.cleanup(undefined, undefined, undefined);
+    }
+}

package/dist/cursor-provider-turn-sdk-normalizer.js

@@ -0,0 +1,74 @@
+import { asRecord } from "./cursor-record-utils.js";
+import { mergeShellOutputDeltasIntoCursorToolCall, } from "./cursor-provider-turn-shell-output.js";
+function mergeCursorToolCalls(startedToolCall, completedToolCall) {
+    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 function resolveCursorToolCompletion(options) {
+    const bridgeStartedCallId = options.ledger.takeBridgeStartedCallId(typeof options.callId === "string" ? options.callId : "");
+    if (bridgeStartedCallId) {
+        options.ledger.recordCompletedIdentity(`cursor-tool:${bridgeStartedCallId}`);
+        return { action: "ignore-bridge", identity: `cursor-tool:${bridgeStartedCallId}` };
+    }
+    let matchedStartedCallId;
+    let resolvedToolCall;
+    let identity;
+    let source;
+    if (options.source === "delta") {
+        const callId = options.callId;
+        identity = typeof callId === "string" ? `cursor-tool:${callId}` : undefined;
+        resolvedToolCall = mergeCursorToolCalls(options.startedToolCall, options.toolCall);
+        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, matchedStartedCallId
+            ? options.shellOutput.takeDeltasForCall(matchedStartedCallId)
+            : typeof callId === "string"
+                ? options.shellOutput.takeDeltasForCall(callId)
+                : undefined);
+        source = identity || matchedStartedCallId ? "started" : "fallback";
+    }
+    else {
+        matchedStartedCallId = options.ledger.removeStartedToolCallForStep(options.toolCall, options.callId);
+        if (matchedStartedCallId) {
+            options.onClearStartedCallId?.(matchedStartedCallId);
+        }
+        resolvedToolCall = mergeShellOutputDeltasIntoCursorToolCall(options.toolCall, matchedStartedCallId ? options.shellOutput.takeDeltasForCall(matchedStartedCallId) : undefined);
+        const identityId = typeof options.callId === "string" ? options.callId : matchedStartedCallId;
+        identity = identityId ? `cursor-tool:${identityId}` : undefined;
+    }
+    if (options.liveRun?.bridgeRun?.isBridgeMcpToolCall(resolvedToolCall)) {
+        const bridgeIdentity = options.source === "step" && matchedStartedCallId ? `cursor-tool:${matchedStartedCallId}` : identity;
+        if (bridgeIdentity)
+            options.ledger.recordCompletedIdentity(bridgeIdentity);
+        return { action: "ignore-bridge", identity: bridgeIdentity };
+    }
+    if (options.source === "delta") {
+        return { action: "handle", toolCall: resolvedToolCall, identity, source, matchedStartedCallId };
+    }
+    return {
+        action: "handle",
+        toolCall: resolvedToolCall,
+        identity,
+        matchedStartedCallId,
+    };
+}

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

@@ -0,0 +1,138 @@
+import { countCursorAgentMessages } from "./cursor-agent-message-web-tools.js";
+import { createCursorCloudLifecyclePersistenceError, recordCursorCloudLifecycleSafely, } from "./cursor-cloud-lifecycle.js";
+import { CursorLiveRunAbortError } from "./cursor-live-run-coordinator.js";
+import { cursorLiveRuns } from "./cursor-provider-live-run-drain.js";
+import { consumeCursorLocalForceOverride } from "./cursor-runtime-state.js";
+import { recordCursorSessionAgentLineage } from "./cursor-session-agent-lineage.js";
+const CLOUD_LEDGER_CANCEL_TIMEOUT_MS = 5000;
+async function requestBoundedCloudRunCancellation(run) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), CLOUD_LEDGER_CANCEL_TIMEOUT_MS);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([
+            Promise.resolve().then(() => run.cancel()).then(() => true, () => false),
+            timeout,
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function recordDebug(action) {
+    try {
+        action();
+    }
+    catch {
+        // Debug capture is optional and must never change provider execution.
+    }
+}
+export async function sendCursorProviderTurn(sendParams) {
+    const { params, prepared, sdkEventDebug, sdkProcessErrorGuard, throwIfAborted, resolvedApiKey } = sendParams;
+    const { options } = params;
+    const { agent, cwd, payload, meta, runtime } = prepared;
+    const { turnCoordinator, liveRun } = runtime;
+    let completed = false;
+    let sdkRun = null;
+    const abortListener = () => {
+        sdkProcessErrorGuard.suppressAbortErrors();
+        liveRun?.bridgeRun?.cancel("Cursor SDK run aborted");
+        if (sdkRun) {
+            sdkRun.cancel().catch(() => { });
+        }
+    };
+    const abortSignal = options?.signal;
+    const abortRegistration = abortSignal
+        ? { signal: abortSignal, listener: abortListener }
+        : undefined;
+    try {
+        abortRegistration?.signal.addEventListener("abort", abortListener, { once: true });
+        throwIfAborted();
+        let cursorAgentMessageOffset;
+        if (prepared.runtimeTarget === "local") {
+            try {
+                cursorAgentMessageOffset = await countCursorAgentMessages(agent.agentId, cwd, prepared.sessionAgentLease.store);
+            }
+            catch (error) {
+                recordDebug(() => sdkEventDebug?.recordError("cursor_agent_message_count", error));
+            }
+        }
+        throwIfAborted();
+        recordDebug(() => sdkEventDebug?.recordSendMeta({
+            mode: meta.sendPlan.mode,
+            reason: meta.sendPlan.reason,
+            resetAgent: meta.sendPlan.resetAgent,
+            bootstrap: meta.bootstrap,
+            promptText: meta.prompt.text,
+            imageCount: meta.prompt.images.length,
+            useNativeToolReplay: meta.useNativeToolReplay,
+            bridgeEnabled: meta.bridgeEnabled,
+            nativeReplayId: meta.nativeReplayId,
+            promptInputTokens: meta.promptInputTokens,
+            agentMode: meta.agentMode,
+        }));
+        recordDebug(() => sdkEventDebug?.recordSendPayload(payload));
+        recordDebug(() => sdkEventDebug?.recordProviderEvent("agent_send_start", payload));
+        const sendOptions = {
+            mode: meta.agentMode,
+            model: meta.modelSelection,
+            onDelta: (args) => {
+                recordDebug(() => sdkEventDebug?.recordOnDelta(args.update));
+                turnCoordinator.handleDelta(args.update);
+            },
+            onStep: (args) => {
+                recordDebug(() => sdkEventDebug?.recordOnStep(args.step));
+                turnCoordinator.handleStep(args.step);
+            },
+        };
+        throwIfAborted();
+        if (prepared.runtimeTarget === "local" && consumeCursorLocalForceOverride(prepared.localForce)) {
+            sendOptions.local = { force: true };
+        }
+        const runPromise = agent.send(payload, sendOptions);
+        // Record at send initiation (promise created), including later reject/cancel paths.
+        if (prepared.runtimeTarget === "local") {
+            recordCursorSessionAgentLineage(agent.agentId);
+        }
+        const run = await runPromise;
+        sdkRun = run;
+        if (prepared.runtimeTarget === "cloud" && !recordCursorCloudLifecycleSafely({ agentId: run.agentId, runId: run.id }, resolvedApiKey)) {
+            const cancellationConfirmed = await requestBoundedCloudRunCancellation(run);
+            throw createCursorCloudLifecyclePersistenceError(run.agentId, "run", cancellationConfirmed, resolvedApiKey);
+        }
+        recordDebug(() => sdkEventDebug?.recordRunMeta({
+            runId: run.id,
+            requestId: run.requestId,
+            agentId: run.agentId,
+            status: run.status,
+        }));
+        recordDebug(() => sdkEventDebug?.attachRunStream(run));
+        recordDebug(() => sdkEventDebug?.recordProviderEvent("agent_send_returned", {
+            runId: run.id,
+            requestId: run.requestId,
+            agentId: run.agentId,
+            status: run.status,
+        }));
+        if (liveRun)
+            cursorLiveRuns.attachSdkRun(liveRun, run);
+        if (options?.signal?.aborted) {
+            sdkProcessErrorGuard.suppressAbortErrors();
+            liveRun?.bridgeRun?.cancel("Cursor SDK run aborted");
+            await run.cancel().catch(() => { });
+            throw new CursorLiveRunAbortError();
+        }
+        completed = true;
+        return {
+            send: { run, cursorAgentMessageOffset },
+            abortRegistration,
+        };
+    }
+    finally {
+        if (!completed && abortRegistration) {
+            abortRegistration.signal.removeEventListener("abort", abortRegistration.listener);
+        }
+    }
+}

package/dist/cursor-provider-turn-shell-output.js

@@ -0,0 +1,117 @@
+import { asRecord, getField, hasUsableText } from "./cursor-record-utils.js";
+import { scrubSensitiveText } from "./cursor-sensitive-text.js";
+import { truncateCursorDisplayLine } from "./cursor-display-text.js";
+import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
+const SHELL_OUTPUT_PROGRESS_MAX_DELTAS_PER_CALL = 3;
+export function isCursorShellToolCall(toolCall) {
+    return classifyCursorToolVisibility(toolCall).normalizedKey === "shell";
+}
+export function getCursorShellOutputDelta(update) {
+    if (update.type !== "shell-output-delta")
+        return undefined;
+    const event = getField(update, "event");
+    const eventCase = getField(event, "case");
+    if (eventCase !== "stdout" && eventCase !== "stderr")
+        return undefined;
+    const value = getField(event, "value");
+    const data = getField(value, "data");
+    if (typeof data !== "string" || data.length === 0)
+        return undefined;
+    return { stream: eventCase, data };
+}
+function getCursorShellOutputProgressPreview(data) {
+    return data
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+}
+export function formatCursorShellOutputProgressText(progress, apiKey) {
+    const preview = getCursorShellOutputProgressPreview(progress.data);
+    if (!preview)
+        return undefined;
+    return `Cursor shell ${progress.stream}: ${truncateCursorDisplayLine(scrubSensitiveText(preview, apiKey), 160)}\n`;
+}
+export function mergeShellOutputDeltasIntoCursorToolCall(toolCall, deltas) {
+    if (!deltas)
+        return toolCall;
+    const stdout = deltas.stdout.join("");
+    const stderr = deltas.stderr.join("");
+    if (!hasUsableText(stdout) && !hasUsableText(stderr))
+        return toolCall;
+    const toolRecord = asRecord(toolCall);
+    const result = getField(toolRecord, "result");
+    const resultRecord = asRecord(result);
+    if (!toolRecord || !resultRecord || resultRecord.status !== "success")
+        return toolCall;
+    const value = getField(resultRecord, "value");
+    const valueRecord = asRecord(value);
+    const completedStdout = getField(valueRecord, "stdout");
+    const completedStderr = getField(valueRecord, "stderr");
+    if (hasUsableText(typeof completedStdout === "string" ? completedStdout : undefined))
+        return toolCall;
+    if (hasUsableText(typeof completedStderr === "string" ? completedStderr : undefined))
+        return toolCall;
+    return {
+        ...toolRecord,
+        result: {
+            ...resultRecord,
+            value: {
+                ...(valueRecord ?? {}),
+                stdout,
+                stderr,
+            },
+        },
+    };
+}
+export class CursorShellOutputTracker {
+    activeShellCallIds = new Set();
+    ambiguousShellOutputCallIds = new Set();
+    shellOutputDeltasByCallId = new Map();
+    shellOutputProgressCountsByCallId = new Map();
+    onShellToolStarted(callId) {
+        this.activeShellCallIds.add(callId);
+    }
+    onShellToolCleared(callId) {
+        this.activeShellCallIds.delete(callId);
+        this.ambiguousShellOutputCallIds.delete(callId);
+        this.shellOutputProgressCountsByCallId.delete(callId);
+    }
+    appendShellOutputDelta(delta) {
+        if (this.activeShellCallIds.size !== 1) {
+            for (const activeCallId of this.activeShellCallIds) {
+                this.ambiguousShellOutputCallIds.add(activeCallId);
+                this.shellOutputDeltasByCallId.delete(activeCallId);
+                this.shellOutputProgressCountsByCallId.delete(activeCallId);
+            }
+            return undefined;
+        }
+        const [callId] = this.activeShellCallIds;
+        if (!callId || this.ambiguousShellOutputCallIds.has(callId))
+            return undefined;
+        let deltas = this.shellOutputDeltasByCallId.get(callId);
+        if (!deltas) {
+            deltas = { stdout: [], stderr: [] };
+            this.shellOutputDeltasByCallId.set(callId, deltas);
+        }
+        deltas[delta.stream].push(delta.data);
+        if (!getCursorShellOutputProgressPreview(delta.data))
+            return undefined;
+        const progressCount = this.shellOutputProgressCountsByCallId.get(callId) ?? 0;
+        if (progressCount >= SHELL_OUTPUT_PROGRESS_MAX_DELTAS_PER_CALL)
+            return undefined;
+        this.shellOutputProgressCountsByCallId.set(callId, progressCount + 1);
+        return { ...delta, callId };
+    }
+    takeDeltasForCall(callId) {
+        const deltas = this.shellOutputDeltasByCallId.get(callId);
+        this.shellOutputDeltasByCallId.delete(callId);
+        this.shellOutputProgressCountsByCallId.delete(callId);
+        return deltas;
+    }
+    clear() {
+        this.activeShellCallIds.clear();
+        this.ambiguousShellOutputCallIds.clear();
+        this.shellOutputDeltasByCallId.clear();
+        this.shellOutputProgressCountsByCallId.clear();
+    }
+}

package/dist/cursor-provider-turn-tool-ledger.js

@@ -0,0 +1,99 @@
+import { getToolArgs, getToolName } from "./cursor-transcript-utils.js";
+export class CursorToolCompletionLedger {
+    startedToolCalls = new Map();
+    bridgeStartedToolCallIds = new Set();
+    completedToolIdentities = new Set();
+    completedStartedToolFingerprints = new Set();
+    completedFallbackToolFingerprints = new Set();
+    getStartedToolCall(callId) {
+        return this.startedToolCalls.get(callId);
+    }
+    hasStartedToolCall(callId) {
+        return this.startedToolCalls.has(callId);
+    }
+    registerStartedToolCall(callId, toolCall) {
+        this.startedToolCalls.set(callId, toolCall);
+    }
+    markBridgeStarted(callId) {
+        this.bridgeStartedToolCallIds.add(callId);
+    }
+    takeBridgeStartedCallId(callId) {
+        if (!this.bridgeStartedToolCallIds.has(callId))
+            return undefined;
+        this.bridgeStartedToolCallIds.delete(callId);
+        return callId;
+    }
+    clearStartedToolCall(callId) {
+        this.startedToolCalls.delete(callId);
+        this.bridgeStartedToolCallIds.delete(callId);
+    }
+    removeStartedToolCallForStep(toolCall, stepId) {
+        if (typeof stepId === "string" && this.startedToolCalls.has(stepId)) {
+            this.clearStartedToolCall(stepId);
+            return stepId;
+        }
+        const fingerprint = getStartedToolCallFingerprint(toolCall);
+        for (const [callId, startedToolCall] of this.startedToolCalls) {
+            if (getStartedToolCallFingerprint(startedToolCall) !== fingerprint)
+                continue;
+            this.clearStartedToolCall(callId);
+            return callId;
+        }
+        return undefined;
+    }
+    recordCompletedIdentity(identity) {
+        this.completedToolIdentities.add(identity);
+    }
+    shouldSkipDuplicateCompletion(input) {
+        if (input.identity && this.completedToolIdentities.has(input.identity)) {
+            return "identity-already-completed";
+        }
+        if (input.source === "started") {
+            if (this.completedFallbackToolFingerprints.has(input.fingerprint)) {
+                return "fallback-fingerprint-already-completed";
+            }
+            return undefined;
+        }
+        if (this.completedStartedToolFingerprints.has(input.fingerprint) ||
+            this.completedFallbackToolFingerprints.has(input.fingerprint)) {
+            return "fingerprint-already-completed";
+        }
+        return undefined;
+    }
+    recordCompletedTool(input) {
+        if (input.identity)
+            this.completedToolIdentities.add(input.identity);
+        if (input.source === "started") {
+            this.completedStartedToolFingerprints.add(input.fingerprint);
+        }
+        else {
+            this.completedFallbackToolFingerprints.add(input.fingerprint);
+        }
+    }
+    clear() {
+        this.startedToolCalls.clear();
+        this.bridgeStartedToolCallIds.clear();
+        this.completedToolIdentities.clear();
+        this.completedStartedToolFingerprints.clear();
+        this.completedFallbackToolFingerprints.clear();
+    }
+    /** Exposed for incomplete-tool discard iteration. */
+    startedToolCallEntries() {
+        return this.startedToolCalls.entries();
+    }
+    clearStartedToolCalls() {
+        this.startedToolCalls.clear();
+        this.bridgeStartedToolCallIds.clear();
+    }
+}
+export function getToolFingerprint(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function getStartedToolCallFingerprint(toolCall) {
+    return getToolFingerprint({ toolName: getToolName(toolCall), args: getToolArgs(toolCall) });
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/cursor-provider.js

@@ -0,0 +1,72 @@
+import { createAssistantMessageEventStream, } from "@earendil-works/pi-ai";
+import { cursorLiveRuns, DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS, getPendingCursorLiveRun, hasTrailingUserMessagesAfterToolResults, releaseAllPendingCursorLiveRunsForTests, resetCursorNativeReplayIdleDisposeMs, setCursorNativeReplayIdleDisposeMs, } from "./cursor-provider-live-run-drain.js";
+import { disposeAllSessionCursorAgents } from "./cursor-session-agent.js";
+import { attachCursorSdkEventDebugPiStreamTap } from "./cursor-sdk-event-debug.js";
+import { installCursorSdkProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
+import { sanitizeCursorProviderError } from "./cursor-provider-errors.js";
+import { resolveCursorApiKey } from "./cursor-api-key.js";
+import { CursorProviderTurnRunner } from "./cursor-provider-turn-runner.js";
+import { getCursorSessionScopeKey } from "./cursor-session-scope.js";
+import { runExclusiveCursorSessionTurn, __testUtils as cursorSessionTurnQueueTestUtils } from "./cursor-session-turn-queue.js";
+function makeInitialMessage(model) {
+    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: "stop",
+        timestamp: Date.now(),
+    };
+}
+export function streamCursor(model, context, options) {
+    const stream = createAssistantMessageEventStream();
+    const sdkEventDebugRef = {};
+    attachCursorSdkEventDebugPiStreamTap(stream, sdkEventDebugRef);
+    (async () => {
+        const partial = makeInitialMessage(model);
+        const runner = new CursorProviderTurnRunner({
+            model,
+            context,
+            stream,
+            partial,
+            options,
+            sdkEventDebugRef,
+        });
+        try {
+            stream.push({ type: "start", partial });
+            await runExclusiveCursorSessionTurn(getCursorSessionScopeKey(), () => runner.run(installCursorSdkProcessErrorGuard()), options?.signal);
+        }
+        catch (error) {
+            await runner.handleOuterCatch(error);
+        }
+        stream.end();
+    })().catch((error) => {
+        const partial = makeInitialMessage(model);
+        partial.stopReason = "error";
+        partial.errorMessage = sanitizeCursorProviderError(error, resolveCursorApiKey(options?.apiKey));
+        stream.push({ type: "error", reason: "error", error: partial });
+        stream.end();
+    });
+    return stream;
+}
+export const __testUtils = {
+    DEFAULT_CURSOR_NATIVE_REPLAY_IDLE_DISPOSE_MS,
+    pendingCursorNativeRunCount: cursorLiveRuns.count,
+    getPendingCursorLiveRun,
+    getActiveCursorLiveRunForScope: cursorLiveRuns.getActiveForScope,
+    hasTrailingUserMessagesAfterToolResults,
+    setCursorNativeReplayIdleDisposeMs,
+    resetCursorNativeReplayIdleDisposeMs,
+    releaseAllPendingCursorLiveRunsForTests,
+    resetSessionCursorAgents: () => disposeAllSessionCursorAgents(),
+    resetSessionTurnQueue: cursorSessionTurnQueueTestUtils.reset,
+};