pi-cursor-sdk 0.2.0 → 0.3.6

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

@@ -0,0 +1,123 @@
+import { spawnSync } from "node:child_process";
+import { CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV, CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX, serializeCursorPiToolBridgeDiagnostic, } from "./cursor-pi-tool-bridge-diagnostics.js";
+import { CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV, CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV, CURSOR_PI_TOOL_BRIDGE_ENV, } from "./cursor-pi-tool-bridge-env.js";
+import { bridgeToolExecutionAbortTracker } from "./cursor-pi-tool-bridge-abort.js";
+import { isCursorPiBridgeToolCallId, MCP_SERVER_NAME } from "./cursor-pi-tool-bridge-constants.js";
+import { LOOPBACK_HOST, CursorPiToolBridgeRegistry } from "./cursor-pi-tool-bridge-server.js";
+export { resolveCursorPiToolBridgeDebugEnabled } from "./cursor-pi-tool-bridge-diagnostics.js";
+export { CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV, CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV, CURSOR_PI_TOOL_BRIDGE_ENV, resolveCursorPiToolBridgeBuiltinsEnabled, resolveCursorPiToolBridgeCallTimeoutMs, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-env.js";
+export { buildCursorPiToolBridgeSnapshot, buildCursorPiToolBridgeSurfaceSignature, } from "./cursor-pi-tool-bridge-snapshot.js";
+let registeredCursorPiToolBridge;
+const WINDOWS_BRIDGE_ABORT_ENV = "PI_CURSOR_BRIDGE_TOOL_CALL_ID";
+function buildWindowsBridgeBashAbortCommand(command, marker) {
+    return `export ${WINDOWS_BRIDGE_ABORT_ENV}=${marker}; ${command}`;
+}
+function installWindowsBridgeBashAbortMarker(event) {
+    if (process.platform !== "win32" || event.toolName !== "bash")
+        return undefined;
+    if (typeof event.input !== "object" || event.input === null || !("command" in event.input))
+        return undefined;
+    const input = event.input;
+    if (typeof input.command !== "string" || input.command.length === 0)
+        return undefined;
+    const marker = event.toolCallId.replace(/[^A-Za-z0-9_.:-]/g, "_");
+    input.command = buildWindowsBridgeBashAbortCommand(input.command, marker);
+    return marker;
+}
+function killWindowsBridgeBashMarkerTree(marker) {
+    if (process.platform !== "win32" || !marker)
+        return;
+    const encodedMarker = Buffer.from(marker, "utf8").toString("base64");
+    const script = `
+$marker = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedMarker}'))
+$needle = '${WINDOWS_BRIDGE_ABORT_ENV}=' + $marker
+$seen = @{}
+function Stop-Tree([int]$ProcessId) {
+  if ($seen.ContainsKey($ProcessId)) { return }
+  $seen[$ProcessId] = $true
+  Get-CimInstance Win32_Process | Where-Object { $_.ParentProcessId -eq $ProcessId } | ForEach-Object { Stop-Tree $_.ProcessId }
+  Stop-Process -Id $ProcessId -Force -ErrorAction SilentlyContinue
+}
+Get-CimInstance Win32_Process -Filter "Name = 'bash.exe' OR Name = 'sh.exe'" |
+  Where-Object { $_.CommandLine -and $_.CommandLine.Contains($needle) } |
+  ForEach-Object { Stop-Tree $_.ProcessId }
+`;
+    spawnSync("powershell.exe", ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
+        stdio: "ignore",
+        timeout: 3_000,
+        windowsHide: true,
+    });
+}
+export function registerCursorPiToolBridge(pi) {
+    bridgeToolExecutionAbortTracker.abortAll("Cursor pi tool bridge extension reloaded");
+    void registeredCursorPiToolBridge?.disposeAll("Cursor pi tool bridge extension reloaded");
+    const bridge = new CursorPiToolBridgeRegistry(pi);
+    registeredCursorPiToolBridge = bridge;
+    pi.on("tool_call", (event, ctx) => {
+        if (registeredCursorPiToolBridge !== bridge)
+            return undefined;
+        if (!bridge.hasPendingPiToolCallId(event.toolCallId)) {
+            return isCursorPiBridgeToolCallId(event.toolCallId)
+                ? { block: true, reason: "Cursor pi bridge tool call is no longer pending" }
+                : undefined;
+        }
+        const windowsAbortMarker = installWindowsBridgeBashAbortMarker(event);
+        const trackingStarted = bridgeToolExecutionAbortTracker.track(event.toolCallId, {
+            signal: ctx.signal,
+            abort: () => {
+                ctx.abort();
+                killWindowsBridgeBashMarkerTree(windowsAbortMarker);
+            },
+            cancelPending: (reason) => {
+                bridge.cancelPendingPiToolCallId(event.toolCallId, reason);
+            },
+        });
+        if (trackingStarted)
+            return undefined;
+        return { block: true, reason: "Cursor pi bridge tool execution was aborted before it started" };
+    });
+    pi.on("tool_result", (event) => {
+        bridgeToolExecutionAbortTracker.finish(event.toolCallId);
+    });
+    pi.on("session_shutdown", async (event) => {
+        const reason = `Cursor pi tool bridge session shutdown: ${event.reason}`;
+        bridgeToolExecutionAbortTracker.abortAll(reason);
+        await bridge.disposeAll(reason);
+    });
+    return bridge;
+}
+export function getRegisteredCursorPiToolBridge() {
+    return registeredCursorPiToolBridge;
+}
+export const __testUtils = {
+    CURSOR_PI_TOOL_BRIDGE_ENV,
+    CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV,
+    CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV,
+    CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV,
+    CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX,
+    LOOPBACK_HOST,
+    MCP_SERVER_NAME,
+    createRegistry(pi, env = process.env) {
+        return new CursorPiToolBridgeRegistry(pi, env);
+    },
+    getRegisteredBridgeForTests() {
+        return registeredCursorPiToolBridge;
+    },
+    serializeDiagnosticForTests(event) {
+        return serializeCursorPiToolBridgeDiagnostic(event);
+    },
+    getActiveBridgeToolExecutionAbortCount() {
+        return bridgeToolExecutionAbortTracker.getActiveCount();
+    },
+    buildWindowsBridgeBashAbortCommandForTests: buildWindowsBridgeBashAbortCommand,
+    installWindowsBridgeBashAbortMarkerForTests: installWindowsBridgeBashAbortMarker,
+    emitBridgeToolExecutionProcessAbortSignalForTests(signal) {
+        bridgeToolExecutionAbortTracker.emitProcessAbortSignalForTests(signal);
+    },
+    resetRegisteredBridgeForTests() {
+        bridgeToolExecutionAbortTracker.abortAll("Cursor pi tool bridge test reset");
+        const bridge = registeredCursorPiToolBridge;
+        registeredCursorPiToolBridge = undefined;
+        return bridge?.disposeAll("Cursor pi tool bridge test reset") ?? Promise.resolve();
+    },
+};

package/dist/cursor-provider-errors.js

@@ -0,0 +1,311 @@
+import { asRecord } from "./cursor-record-utils.js";
+import { scrubSensitiveText } from "./cursor-sensitive-text.js";
+export const MISSING_CURSOR_API_KEY_MESSAGE = "Cursor SDK runs require a Cursor SDK API key. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, set CURSOR_API_KEY before starting pi, or restart pi with --api-key.";
+const GENERIC_CURSOR_SDK_ERROR_MESSAGE = "Cursor SDK request failed. The Cursor SDK API key may be missing, invalid, or unauthorized. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
+const AUTH_CURSOR_SDK_ERROR_MESSAGE = "Cursor SDK request failed because the Cursor SDK API key may be invalid or unauthorized. Cursor Agent CLI/Desktop login is not reused. Run /login -> Use an API key -> Cursor, verify CURSOR_API_KEY, or pass --api-key, then retry.";
+const CLOUD_AUTH_CURSOR_SDK_ERROR_MESSAGE = "Cursor Cloud Agents request failed because Cloud API authentication rejected the API key. Use a user API key from Cursor Dashboard -> API Keys or a service account API key from Team settings; Team Admin API keys are not supported as Cursor Cloud Agents credentials. Configure the key with /login -> Use an API key -> Cursor, CURSOR_API_KEY, or --api-key, then retry.";
+// Keep "Network error" aligned with pi's agent-level retry classifier.
+const NETWORK_CURSOR_SDK_ERROR_MESSAGE = "Network error: Cursor SDK request failed during network or service I/O. Check your connection; pi will retry automatically when auto-retry is enabled.";
+// Keep this phrase aligned with pi's agent-level retry classifier (`provider.?returned.?error`).
+const RETRYABLE_CURSOR_RUN_FAILURE_PREFIX = "Provider returned error: Cursor SDK run failed";
+function isGenericErrorMessage(message) {
+    const normalized = message.trim().toLowerCase();
+    return normalized === "" || normalized === "error" || normalized === "unknown error";
+}
+function isGenericCursorRunFailureMessage(message) {
+    return /^cursor sdk run failed\.?$/i.test(message.trim());
+}
+function isKnownGenericRunFailureText(message) {
+    const normalized = message.trim().toLowerCase();
+    return normalized === "" || isGenericCursorRunFailureMessage(message) || isGenericErrorMessage(normalized);
+}
+function isLikelyAuthError(message) {
+    return /\b(unauthenticated|unauthorized|unauthorised|forbidden|invalid api key|invalid key|authentication|auth|401|403)\b/i.test(message);
+}
+function getErrorStringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function getErrorName(error, record) {
+    return error instanceof Error ? error.name : getErrorStringField(record, "name");
+}
+function scrubHttpsHelpUrl(helpUrl, apiKey) {
+    if (!helpUrl)
+        return undefined;
+    try {
+        const url = new URL(helpUrl);
+        if (url.protocol !== "https:")
+            return undefined;
+        url.username = "";
+        url.password = "";
+        url.pathname = url.pathname
+            .split("/")
+            .map((segment) => {
+            const decoded = decodeURIComponent(segment);
+            const scrubbed = scrubSensitiveText(decoded, apiKey);
+            return scrubbed === decoded ? segment : encodeURIComponent(scrubbed);
+        })
+            .join("/");
+        const scrubbedParams = new URLSearchParams();
+        for (const [name, value] of url.searchParams) {
+            const scrubbedName = scrubSensitiveText(name, apiKey);
+            const scrubbedPair = scrubSensitiveText(`${name}=${value}`, apiKey);
+            scrubbedParams.append(scrubbedName, scrubbedPair === `${name}=${value}` ? value : "[redacted]");
+        }
+        url.search = scrubbedParams.toString();
+        if (url.hash) {
+            const decoded = decodeURIComponent(url.hash.slice(1));
+            const scrubbed = scrubSensitiveText(decoded, apiKey);
+            if (scrubbed !== decoded)
+                url.hash = encodeURIComponent(scrubbed);
+        }
+        return scrubSensitiveText(url.href, apiKey).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatIntegrationNotConnectedError(error, record, scrubbedMessage, apiKey) {
+    if (getErrorName(error, record) !== "IntegrationNotConnectedError")
+        return undefined;
+    const provider = scrubSensitiveText(getErrorStringField(record, "provider") ?? "", apiKey).trim();
+    if (!provider)
+        return undefined;
+    const message = scrubbedMessage || "Cursor Cloud integration is not connected.";
+    const punctuation = /[.!?]$/.test(message) ? "" : ".";
+    const helpUrl = scrubHttpsHelpUrl(getErrorStringField(record, "helpUrl"), apiKey);
+    return `${message}${punctuation} Connect the ${provider} integration${helpUrl ? `: ${helpUrl}` : "."}`;
+}
+function getErrorStack(error, record) {
+    return error instanceof Error ? error.stack ?? "" : getErrorStringField(record, "stack") ?? "";
+}
+const CONNECT_ERROR_EVIDENCE_KEYS = ["name", "message", "rawMessage", "code", "syscall"];
+function getErrorEvidenceField(value, record, key) {
+    if (value instanceof Error && (key === "name" || key === "message"))
+        return value[key] || undefined;
+    const field = record?.[key];
+    if (typeof field === "string")
+        return field;
+    if (typeof field === "number")
+        return String(field);
+    return undefined;
+}
+function collectConnectErrorEvidence(error, record) {
+    const evidence = [];
+    let value = error;
+    let currentRecord = record;
+    for (let depth = 0; depth < 3 && currentRecord; depth += 1) {
+        for (const key of CONNECT_ERROR_EVIDENCE_KEYS) {
+            const field = getErrorEvidenceField(value, currentRecord, key)?.trim();
+            if (field)
+                evidence.push(field);
+        }
+        value = currentRecord.cause;
+        currentRecord = asRecord(value);
+    }
+    return evidence.join("\n");
+}
+function collectConnectErrorStacks(error, record) {
+    const stacks = [];
+    let value = error;
+    let currentRecord = record;
+    for (let depth = 0; depth < 3 && currentRecord; depth += 1) {
+        const stack = getErrorStack(value, currentRecord).trim();
+        if (stack)
+            stacks.push(stack);
+        value = currentRecord.cause;
+        currentRecord = asRecord(value);
+    }
+    return stacks.join("\n");
+}
+function isConnectError(error, record) {
+    const name = error instanceof Error ? error.name : getErrorStringField(record, "name");
+    return name === "ConnectError";
+}
+function isUnauthenticatedConnectCode(code) {
+    return code === 16 || (typeof code === "string" && /^(?:16|unauthenticated)$/i.test(code));
+}
+function isUnavailableConnectCode(code) {
+    return code === 14 || (typeof code === "string" && /^(?:14|unavailable)$/i.test(code));
+}
+function isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence) {
+    return ((code === 2 || (typeof code === "string" && /^(?:2|unknown)$/i.test(code))) &&
+        /(?:operation was aborted|canceled)/i.test(evidence) &&
+        /(?:AbortError|operation was aborted)/i.test(`${evidence}\n${stackEvidence}`) &&
+        stackEvidence.includes("@cursor/sdk") &&
+        stackEvidence.includes("@connectrpc/connect-node") &&
+        /\b(?:onStall|reportStall|StallDetected)\b/i.test(stackEvidence));
+}
+/**
+ * @cursor/sdk@1.0.27 throws internal RetriableError (name/kind "RetriableError") with message
+ * "Connection stalled" or "Connection stalled repeatedly" after fetchWithRetry exhausts stalls.
+ * The ConnectError is only the cause; the top-level error is not a ConnectError.
+ */
+export function isCursorSdkConnectionStalledError(error) {
+    const record = asRecord(error);
+    if (!record)
+        return false;
+    const name = getErrorName(error, record) ?? getErrorStringField(record, "kind");
+    if (name !== "RetriableError")
+        return false;
+    const message = (error instanceof Error ? error.message : getErrorStringField(record, "message") ?? "").trim();
+    if (!/^Connection stalled(?: repeatedly)?$/i.test(message))
+        return false;
+    const stack = getErrorStack(error, record);
+    return /(?:^|[\\/])node_modules[\\/]@cursor[\\/]sdk[\\/]dist[\\/]/.test(stack) || stack.includes("@cursor/sdk");
+}
+function isCursorExtensionConnectStack(stack) {
+    // pi runs Cursor SDK in Node, where the SDK dynamically imports connect-node.
+    // connect-web is the SDK's Bun/Deno path and is intentionally not classified for supported pi runs.
+    return stack.includes("@connectrpc/connect-node") && /(?:^|[\\/])pi-cursor-sdk(?:[\\/]|$)/.test(stack);
+}
+function getCursorConnectSource(error, record) {
+    const stack = getErrorStack(error, record);
+    if (stack.includes("@cursor/sdk"))
+        return "cursor-sdk-stack";
+    if (isCursorExtensionConnectStack(stack))
+        return "cursor-extension-connect-stack";
+    const details = Array.isArray(record?.details) ? record.details : [];
+    const hasCursorBackendDetails = details.some((detail) => {
+        const type = getErrorStringField(asRecord(detail), "type");
+        return typeof type === "string" && type.startsWith("aiserver.");
+    });
+    if (hasCursorBackendDetails)
+        return "cursor-backend-details";
+    return stack.includes("@connectrpc/connect-node") ? "connect-node-stack" : "generic-connect";
+}
+export function classifyCursorConnectError(error) {
+    const record = asRecord(error);
+    if (!isConnectError(error, record))
+        return undefined;
+    const message = error instanceof Error ? error.message : getErrorStringField(record, "message") ?? "";
+    const rawMessage = getErrorStringField(record, "rawMessage") ?? message;
+    const code = record?.code;
+    const cause = asRecord(record?.cause);
+    const causeName = getErrorStringField(cause, "name");
+    const stack = getErrorStack(error, record);
+    const evidence = collectConnectErrorEvidence(error, record);
+    const stackEvidence = collectConnectErrorStacks(error, record);
+    if ((code === 1 || code === "canceled") &&
+        Boolean(rawMessage && /(?:operation was aborted|canceled)/i.test(rawMessage)) &&
+        (causeName === "AbortError" || /AbortError/.test(stack)) &&
+        stack.includes("@cursor/sdk") &&
+        stack.includes("@connectrpc/connect-node")) {
+        return { kind: "abort", source: "cursor-sdk-stack" };
+    }
+    if (isCursorSdkStallAbortNetworkError(code, evidence, stackEvidence)) {
+        return { kind: "network", source: getCursorConnectSource(error, record) };
+    }
+    if (isUnauthenticatedConnectCode(code) || isLikelyAuthError(evidence)) {
+        return { kind: "unauthenticated", source: getCursorConnectSource(error, record) };
+    }
+    if (isUnavailableConnectCode(code)) {
+        return { kind: "network", source: getCursorConnectSource(error, record) };
+    }
+    if (isLikelyNetworkTimeout(evidence)) {
+        return { kind: "network", source: getCursorConnectSource(error, record) };
+    }
+    return undefined;
+}
+export function isCursorSdkAbortConnectError(error) {
+    return classifyCursorConnectError(error)?.kind === "abort";
+}
+export function isUnauthenticatedConnectError(error) {
+    return classifyCursorConnectError(error)?.kind === "unauthenticated";
+}
+function isLikelyNetworkTimeout(message) {
+    return (/\b(ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENETUNREACH|EAI_AGAIN|NGHTTP2_ENHANCE_YOUR_CALM|ERR_HTTP2_STREAM_ERROR|ERR_HTTP2_SESSION_ERROR)\b/i.test(message) ||
+        /\bConnectError\b.*\b(unavailable|deadline|timeout|timed out)\b/i.test(message) ||
+        /\b(?:stream|session) closed with error code\b/i.test(message) ||
+        /\bread ETIMEDOUT\b/i.test(message));
+}
+function shortRunId(runId) {
+    const trimmed = runId.trim();
+    if (trimmed.length <= 12)
+        return trimmed;
+    return `${trimmed.slice(0, 8)}…`;
+}
+function runErrorCode(error) {
+    return error?.code?.trim() || undefined;
+}
+function nonGenericRunErrorMessage(error) {
+    const message = error?.message?.trim();
+    return message && !isKnownGenericRunFailureText(message) ? message : undefined;
+}
+function withRunErrorCode(message, code) {
+    return code ? `${message} (code: ${code})` : message;
+}
+export function formatCursorSdkRunFailureDetail(result, runResult, runError) {
+    const errorCode = runErrorCode(result.error) ?? runErrorCode(runError);
+    const fromWaitError = nonGenericRunErrorMessage(result.error);
+    if (fromWaitError)
+        return withRunErrorCode(fromWaitError, errorCode);
+    const fromWait = result.result?.trim();
+    if (fromWait && !isKnownGenericRunFailureText(fromWait)) {
+        return withRunErrorCode(fromWait, errorCode);
+    }
+    const fromRunError = nonGenericRunErrorMessage(runError);
+    if (fromRunError)
+        return withRunErrorCode(fromRunError, errorCode);
+    const fromRun = runResult?.trim();
+    if (fromRun && !isKnownGenericRunFailureText(fromRun)) {
+        return withRunErrorCode(fromRun, errorCode);
+    }
+    const parts = [RETRYABLE_CURSOR_RUN_FAILURE_PREFIX];
+    if (errorCode)
+        parts.push(`code ${errorCode}`);
+    if (result.model?.id)
+        parts.push(`model ${result.model.id}`);
+    parts.push(`run ${shortRunId(result.id)}`);
+    if (result.requestId)
+        parts.push(`request ${shortRunId(result.requestId)}`);
+    if (typeof result.durationMs === "number")
+        parts.push(`${result.durationMs}ms`);
+    return parts.join(" · ");
+}
+export function formatCursorSdkAbortMessage(cause) {
+    switch (cause) {
+        case "user_interrupt":
+            return "Cancelled: prompt interrupted.";
+        case "sdk_cancelled":
+            return "Cancelled: Cursor SDK run was cancelled.";
+        case "live_run_disposed":
+            return "Cancelled: Cursor SDK live run ended before completion.";
+        case "unknown":
+            return "Cancelled: Cursor SDK run aborted.";
+    }
+}
+export function resolveCursorSdkAbortCause(options) {
+    if (options.signalAborted)
+        return "user_interrupt";
+    if (options.sdkStatusCancelled)
+        return "sdk_cancelled";
+    if (options.liveRunDisposed)
+        return "live_run_disposed";
+    return "unknown";
+}
+export function sanitizeCursorProviderError(error, apiKey, runtimeTarget) {
+    const record = asRecord(error);
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+    if (message === MISSING_CURSOR_API_KEY_MESSAGE)
+        return MISSING_CURSOR_API_KEY_MESSAGE;
+    const scrubbed = scrubSensitiveText(message, apiKey).trim();
+    const integrationMessage = runtimeTarget === "cloud"
+        ? formatIntegrationNotConnectedError(error, record, scrubbed, apiKey)
+        : undefined;
+    if (integrationMessage)
+        return integrationMessage;
+    const connectClassification = classifyCursorConnectError(error);
+    if ((runtimeTarget === "cloud" && getErrorName(error, record) === "AuthenticationError") ||
+        connectClassification?.kind === "unauthenticated" ||
+        isLikelyAuthError(scrubbed)) {
+        return runtimeTarget === "cloud" ? CLOUD_AUTH_CURSOR_SDK_ERROR_MESSAGE : AUTH_CURSOR_SDK_ERROR_MESSAGE;
+    }
+    if (connectClassification?.kind === "network" || isCursorSdkConnectionStalledError(error) || isLikelyNetworkTimeout(scrubbed))
+        return NETWORK_CURSOR_SDK_ERROR_MESSAGE;
+    if (isGenericCursorRunFailureMessage(scrubbed))
+        return RETRYABLE_CURSOR_RUN_FAILURE_PREFIX;
+    if (isGenericErrorMessage(scrubbed))
+        return GENERIC_CURSOR_SDK_ERROR_MESSAGE;
+    return scrubbed || GENERIC_CURSOR_SDK_ERROR_MESSAGE;
+}

package/dist/cursor-provider-lazy.js

@@ -0,0 +1,39 @@
+import { createAssistantMessageEventStream, } from "@earendil-works/pi-ai";
+import { streamCursor } from "./cursor-provider.js";
+import { sanitizeCursorProviderError } from "./cursor-provider-errors.js";
+function makeProviderRuntimeErrorMessage(model, error, apiKey) {
+    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: `Cursor provider runtime failed: ${sanitizeCursorProviderError(error, apiKey)}`,
+    };
+}
+export function streamCursorLazy(model, context, options) {
+    const outer = createAssistantMessageEventStream();
+    queueMicrotask(async () => {
+        try {
+            for await (const event of streamCursor(model, context, options)) {
+                outer.push(event);
+            }
+        }
+        catch (error) {
+            const message = makeProviderRuntimeErrorMessage(model, error, options?.apiKey);
+            outer.push({ type: "error", reason: "error", error: message });
+            outer.end(message);
+        }
+    });
+    return outer;
+}