opencode-ext-connector 0.3.0

package/dist/providers/cursor/http2.d.ts

@@ -0,0 +1,18 @@
+export declare const CURSOR_API_URL = "https://api2.cursor.sh";
+export declare const CURSOR_CLIENT_VERSION = "cli-2026.08.11-e8db854";
+export type CursorHttp2Post = {
+    readonly path: string;
+    readonly token: string;
+    readonly body: Uint8Array;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly signal: AbortSignal;
+    readonly keepOpen?: boolean;
+    readonly heartbeat?: Uint8Array;
+    readonly onWriter?: (write: (frame: Uint8Array) => void) => void;
+};
+export type CursorHttp2Response = {
+    readonly status: number;
+    readonly body: Uint8Array;
+};
+export declare function cursorHttp2Post(request: CursorHttp2Post): Promise<CursorHttp2Response>;
+export declare function cursorHttp2Stream(request: CursorHttp2Post): AsyncIterable<Uint8Array>;

package/dist/providers/cursor/http2.js

@@ -0,0 +1,144 @@
+import http2 from "node:http2";
+import { OperationCancelledError } from "../../core/errors";
+export const CURSOR_API_URL = "https://api2.cursor.sh";
+export const CURSOR_CLIENT_VERSION = "cli-2026.08.11-e8db854";
+export async function cursorHttp2Post(request) {
+    if (request.signal.aborted) {
+        throw new OperationCancelledError("cursor-http2");
+    }
+    const client = http2.connect(CURSOR_API_URL);
+    try {
+        return await new Promise((resolve, reject) => {
+            const fail = (error) => {
+                reject(error);
+            };
+            const onAbort = () => {
+                fail(new OperationCancelledError("cursor-http2"));
+            };
+            request.signal.addEventListener("abort", onAbort, { once: true });
+            const req = client.request(requestHeaders(request));
+            const chunks = [];
+            let status = 0;
+            req.on("response", (headers) => {
+                const raw = headers[":status"];
+                status = typeof raw === "number" ? raw : Number(raw ?? 0);
+            });
+            req.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            req.on("end", () => {
+                request.signal.removeEventListener("abort", onAbort);
+                resolve({ status, body: new Uint8Array(Buffer.concat(chunks)) });
+            });
+            req.on("error", (error) => {
+                request.signal.removeEventListener("abort", onAbort);
+                fail(error);
+            });
+            writeHttp2Body(req, request.body, true);
+        });
+    }
+    finally {
+        client.close();
+    }
+}
+function toBuffer(body) {
+    const payload = Buffer.alloc(body.length);
+    payload.set(body);
+    return payload;
+}
+function writeHttp2Body(req, body, endStream) {
+    if (body.length === 0) {
+        if (endStream) {
+            req.end();
+        }
+        return;
+    }
+    if (endStream) {
+        req.end(toBuffer(body));
+        return;
+    }
+    req.write(toBuffer(body));
+}
+function requestHeaders(request) {
+    return {
+        ":method": "POST",
+        ":path": request.path,
+        authorization: `Bearer ${request.token}`,
+        "x-ghost-mode": "true",
+        "x-cursor-client-version": CURSOR_CLIENT_VERSION,
+        "x-cursor-client-type": "cli",
+        ...request.headers,
+    };
+}
+export async function* cursorHttp2Stream(request) {
+    if (request.signal.aborted) {
+        throw new OperationCancelledError("cursor-http2");
+    }
+    const client = http2.connect(CURSOR_API_URL);
+    const pending = [];
+    let resume = null;
+    const push = (item) => {
+        pending.push(item);
+        resume?.();
+    };
+    const onAbort = () => {
+        push(new OperationCancelledError("cursor-http2"));
+    };
+    request.signal.addEventListener("abort", onAbort, { once: true });
+    try {
+        const req = client.request(requestHeaders(request));
+        req.on("data", (chunk) => {
+            push(new Uint8Array(chunk));
+        });
+        req.on("end", () => {
+            push(null);
+        });
+        req.on("error", (error) => {
+            push(error);
+        });
+        request.onWriter?.((frame) => {
+            if (!req.destroyed) {
+                req.write(toBuffer(frame));
+            }
+        });
+        writeHttp2Body(req, request.body, request.keepOpen !== true);
+        const heartbeat = request.heartbeat;
+        if (request.keepOpen === true && heartbeat !== undefined && heartbeat.length > 0) {
+            req.write(toBuffer(heartbeat));
+        }
+        const timer = request.keepOpen === true && heartbeat !== undefined && heartbeat.length > 0
+            ? setInterval(() => {
+                if (!req.destroyed) {
+                    req.write(toBuffer(heartbeat));
+                }
+            }, 5_000)
+            : null;
+        timer?.unref();
+        try {
+            for (;;) {
+                while (pending.length === 0) {
+                    await new Promise((resolve) => {
+                        resume = resolve;
+                    });
+                }
+                const next = pending.shift();
+                if (next === undefined || next === null) {
+                    return;
+                }
+                if (next instanceof Error) {
+                    throw next;
+                }
+                yield next;
+            }
+        }
+        finally {
+            if (timer !== null) {
+                clearInterval(timer);
+            }
+        }
+    }
+    finally {
+        request.signal.removeEventListener("abort", onAbort);
+        client.close();
+    }
+}

package/dist/providers/cursor/interaction-reply.d.ts

@@ -0,0 +1,6 @@
+import type { InteractionQuery, InteractionResponse } from "./proto/interaction-query";
+export type CursorInteractionReply = {
+    readonly action: "acked" | "rejected";
+    readonly response: InteractionResponse;
+};
+export declare function buildCursorInteractionReply(query: InteractionQuery): CursorInteractionReply;

package/dist/providers/cursor/interaction-reply.js

@@ -0,0 +1,52 @@
+// Derived from Rahularya01/pi-cursor src/stream/interaction-query.ts. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { unreachableVariant } from "./proto/errors";
+import { encodeBytesField, encodeStringField } from "./proto-wire";
+const REJECT_REASON = "Not available through the Pi Cursor provider. Use Pi tools (web_search, fetch, bash, etc.) instead.";
+const ASK_QUESTION_ERROR = "Interactive questions are not available in Pi. Continue with a reasonable default or ask the user in chat.";
+const CREATE_PLAN_ERROR = "Create-plan UI is not available in Pi. Write the plan with Pi file tools.";
+function rejectionPayload() {
+    return encodeBytesField(2, encodeStringField(1, REJECT_REASON));
+}
+function askQuestionErrorPayload() {
+    return encodeBytesField(1, encodeBytesField(2, encodeStringField(1, ASK_QUESTION_ERROR)));
+}
+function createPlanErrorPayload() {
+    return encodeBytesField(1, encodeBytesField(2, encodeStringField(1, CREATE_PLAN_ERROR)));
+}
+function setupVmSuccessPayload() {
+    return encodeBytesField(1, new Uint8Array());
+}
+function rejectedResponse(query) {
+    return {
+        action: "rejected",
+        response: { kind: query.kind, id: query.id, payload: rejectionPayload() },
+    };
+}
+export function buildCursorInteractionReply(query) {
+    switch (query.kind) {
+        case "web-search":
+        case "switch-mode":
+        case "exa-search":
+        case "exa-fetch":
+        case "field-9":
+            return rejectedResponse(query);
+        case "ask-question":
+            return {
+                action: "rejected",
+                response: { kind: query.kind, id: query.id, payload: askQuestionErrorPayload() },
+            };
+        case "create-plan":
+            return {
+                action: "rejected",
+                response: { kind: query.kind, id: query.id, payload: createPlanErrorPayload() },
+            };
+        case "setup-vm":
+            return {
+                action: "acked",
+                response: { kind: query.kind, id: query.id, payload: setupVmSuccessPayload() },
+            };
+        default:
+            return unreachableVariant(query.kind, "InteractionQuery kind");
+    }
+}

package/dist/providers/cursor/language-generate.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelV3GenerateResult, LanguageModelV3StreamPart } from "@ai-sdk/provider";
+export declare function generateFromCursorStream(stream: ReadableStream<LanguageModelV3StreamPart>): Promise<LanguageModelV3GenerateResult>;

package/dist/providers/cursor/language-generate.js

@@ -0,0 +1,35 @@
+import { emptyCursorUsage } from "./usage";
+export async function generateFromCursorStream(stream) {
+    const content = [];
+    const text = [];
+    const reasoning = [];
+    let finishReason = { unified: "stop", raw: "stop" };
+    let usage = emptyCursorUsage();
+    for await (const part of stream) {
+        if (part.type === "text-delta")
+            text.push(part.delta);
+        else if (part.type === "reasoning-delta")
+            reasoning.push(part.delta);
+        else if (part.type === "tool-call") {
+            content.push({
+                type: "tool-call",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input,
+            });
+        }
+        else if (part.type === "finish") {
+            finishReason = part.finishReason;
+            usage = part.usage;
+        }
+        else if (part.type === "error")
+            throw part.error;
+    }
+    const joinedText = text.join("");
+    if (joinedText.length > 0)
+        content.unshift({ type: "text", text: joinedText });
+    const joinedReasoning = reasoning.join("");
+    if (joinedReasoning.length > 0)
+        content.unshift({ type: "reasoning", text: joinedReasoning });
+    return { content, finishReason, usage, warnings: [] };
+}

package/dist/providers/cursor/language-model.d.ts

@@ -0,0 +1,13 @@
+import type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import { type CursorNdjsonStream } from "./legacy-stream";
+export type CursorLanguageModelOptions = {
+    readonly modelId: string;
+    readonly runPrompt: (prompt: string, signal: AbortSignal) => Promise<string | null>;
+    readonly directRuntime?: {
+        readonly doStream: (call: LanguageModelV3CallOptions, modelId: string) => Promise<{
+            readonly stream: ReadableStream<LanguageModelV3StreamPart>;
+        }>;
+    };
+    readonly streamNdjson?: CursorNdjsonStream;
+};
+export declare function createCursorLanguageModel(options: CursorLanguageModelOptions): LanguageModelV3;

package/dist/providers/cursor/language-model.js

@@ -0,0 +1,77 @@
+// Derived from Nomadcxx/opencode-cursor@8e14a26c1e080382f471a729436092ef72edf34e.
+// Licensed under BSD-3-Clause. See THIRD_PARTY_NOTICES.md.
+import { AdapterError, OperationCancelledError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { generateFromCursorStream } from "./language-generate";
+import { createCursorLegacyStream } from "./legacy-stream";
+import { cursorPromptText } from "./prompt";
+import { emptyCursorUsage } from "./usage";
+export function createCursorLanguageModel(options) {
+    const provider = parseProviderId("cursor");
+    const model = {
+        specificationVersion: "v3",
+        provider,
+        modelId: options.modelId,
+        supportedUrls: {},
+        doGenerate: async (call) => {
+            if (options.directRuntime !== undefined) {
+                return generateFromCursorStream((await options.directRuntime.doStream(call, options.modelId)).stream);
+            }
+            if (options.streamNdjson !== undefined) {
+                return generateFromCursorStream((await model.doStream(call)).stream);
+            }
+            const signal = call.abortSignal ?? new AbortController().signal;
+            if (signal.aborted) {
+                throw new OperationCancelledError("cursor-generate");
+            }
+            const text = await options.runPrompt(cursorPromptText(call), signal);
+            if (text === null) {
+                throw new AdapterError({
+                    operation: "cursor-agent-unavailable",
+                    retryable: false,
+                    cause: null,
+                    providerId: provider,
+                });
+            }
+            return {
+                content: [{ type: "text", text }],
+                finishReason: { unified: "stop", raw: "stop" },
+                usage: emptyCursorUsage(),
+                warnings: [],
+            };
+        },
+        doStream: async (call) => {
+            if (options.directRuntime !== undefined) {
+                return options.directRuntime.doStream(call, options.modelId);
+            }
+            const signal = call.abortSignal ?? new AbortController().signal;
+            if (signal.aborted) {
+                throw new OperationCancelledError("cursor-stream");
+            }
+            const streamNdjson = options.streamNdjson;
+            if (streamNdjson !== undefined) {
+                return { stream: createCursorLegacyStream({ call, signal, streamNdjson }) };
+            }
+            // Fallback to runPrompt (non-streaming)
+            const generated = await createCursorLanguageModel(options).doGenerate(call);
+            const textPart = generated.content.at(0);
+            const text = textPart !== undefined && textPart.type === "text" ? textPart.text : "";
+            const stream = new ReadableStream({
+                start(controller) {
+                    controller.enqueue({ type: "stream-start", warnings: [] });
+                    controller.enqueue({ type: "text-start", id: "text-1" });
+                    controller.enqueue({ type: "text-delta", id: "text-1", delta: text });
+                    controller.enqueue({ type: "text-end", id: "text-1" });
+                    controller.enqueue({
+                        type: "finish",
+                        finishReason: generated.finishReason,
+                        usage: generated.usage,
+                    });
+                    controller.close();
+                },
+            });
+            return { stream };
+        },
+    };
+    return model;
+}

package/dist/providers/cursor/legacy-stream.d.ts

@@ -0,0 +1,11 @@
+import type { LanguageModelV3CallOptions, LanguageModelV3StreamPart } from "@ai-sdk/provider";
+export type CursorNdjsonStream = (prompt: string, signal: AbortSignal, sessionKey: string | null, incrementalPrompt: string | null, tools?: readonly {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: unknown;
+}[]) => AsyncIterable<string>;
+export declare function createCursorLegacyStream(options: {
+    readonly call: LanguageModelV3CallOptions;
+    readonly signal: AbortSignal;
+    readonly streamNdjson: CursorNdjsonStream;
+}): ReadableStream<LanguageModelV3StreamPart>;

package/dist/providers/cursor/legacy-stream.js

@@ -0,0 +1,115 @@
+import { OperationCancelledError } from "../../core/errors";
+import { cursorResultError, cursorTextFromUnknown } from "./ndjson";
+import { cursorIncrementalPrompt, cursorPromptText, cursorSessionKey } from "./prompt";
+import { cursorToolParts } from "./tool-stream";
+import { cursorUsage, emptyCursorUsage } from "./usage";
+export function createCursorLegacyStream(options) {
+    const allowedTools = new Map((options.call.tools ?? [])
+        .filter((tool) => tool.type === "function")
+        .map((tool) => [tool.name, tool.inputSchema]));
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                controller.enqueue({ type: "stream-start", warnings: [] });
+                let textStarted = false;
+                let reasoningStarted = false;
+                let reasoningText = "";
+                let assistantText = "";
+                let toolCalled = false;
+                let usage = emptyCursorUsage();
+                streamLoop: for await (const line of options.streamNdjson(cursorPromptText(options.call), options.signal, cursorSessionKey(options.call), cursorIncrementalPrompt(options.call), (options.call.tools ?? [])
+                    .filter((tool) => tool.type === "function")
+                    .map((tool) => ({
+                    name: tool.name,
+                    ...(tool.description === undefined ? {} : { description: tool.description }),
+                    inputSchema: tool.inputSchema,
+                })))) {
+                    if (options.signal.aborted)
+                        throw new OperationCancelledError("cursor-stream");
+                    const trimmed = line.trim();
+                    if (trimmed.length === 0)
+                        continue;
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(trimmed);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (typeof parsed !== "object" || parsed === null)
+                        continue;
+                    const type = "type" in parsed && typeof parsed.type === "string" ? parsed.type : "";
+                    if (type === "thinking") {
+                        const text = cursorTextFromUnknown(parsed) ?? "";
+                        const delta = text.startsWith(reasoningText) ? text.slice(reasoningText.length) : text;
+                        reasoningText = text.startsWith(reasoningText) ? text : reasoningText + text;
+                        if (delta.length > 0) {
+                            if (!reasoningStarted) {
+                                controller.enqueue({ type: "reasoning-start", id: "reasoning-1" });
+                                reasoningStarted = true;
+                            }
+                            controller.enqueue({ type: "reasoning-delta", id: "reasoning-1", delta });
+                        }
+                        continue;
+                    }
+                    if (reasoningStarted) {
+                        controller.enqueue({ type: "reasoning-end", id: "reasoning-1" });
+                        reasoningStarted = false;
+                    }
+                    for (const part of cursorToolParts(parsed, allowedTools)) {
+                        controller.enqueue(part);
+                        if (part.type === "tool-call" && part.providerExecuted !== true) {
+                            toolCalled = true;
+                            break streamLoop;
+                        }
+                    }
+                    if (!["assistant", "text", "text-delta", "result"].includes(type))
+                        continue;
+                    const text = cursorTextFromUnknown(parsed) ?? "";
+                    let nextText = text;
+                    if (type === "assistant") {
+                        if (text === assistantText)
+                            nextText = "";
+                        else if (text.startsWith(assistantText)) {
+                            nextText = text.slice(assistantText.length);
+                            assistantText = text;
+                        }
+                        else
+                            assistantText += text;
+                    }
+                    else if (type === "result") {
+                        const resultError = cursorResultError(parsed);
+                        if (resultError !== null)
+                            throw resultError;
+                        nextText = assistantText.length > 0 ? "" : text;
+                        usage = cursorUsage(parsed) ?? usage;
+                    }
+                    if (nextText.length > 0) {
+                        if (!textStarted) {
+                            controller.enqueue({ type: "text-start", id: "text-1" });
+                            textStarted = true;
+                        }
+                        controller.enqueue({ type: "text-delta", id: "text-1", delta: nextText });
+                    }
+                }
+                if (options.signal.aborted)
+                    throw new OperationCancelledError("cursor-stream");
+                if (reasoningStarted)
+                    controller.enqueue({ type: "reasoning-end", id: "reasoning-1" });
+                if (textStarted)
+                    controller.enqueue({ type: "text-end", id: "text-1" });
+                controller.enqueue({
+                    type: "finish",
+                    finishReason: toolCalled
+                        ? { unified: "tool-calls", raw: "tool_calls" }
+                        : { unified: "stop", raw: "stop" },
+                    usage,
+                });
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}

package/dist/providers/cursor/mcp-tools.d.ts

@@ -0,0 +1,7 @@
+export type CursorMcpTool = {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: unknown;
+};
+export declare function encodeMcpToolDefinition(tool: CursorMcpTool): Uint8Array;
+export declare function encodeCursorMcpTools(tools: readonly CursorMcpTool[]): Uint8Array;

package/dist/providers/cursor/mcp-tools.js

@@ -0,0 +1,15 @@
+import { encodeProtobufValue } from "./proto-value";
+import { concatBytes, encodeBytesField, encodeStringField } from "./proto-wire";
+export function encodeMcpToolDefinition(tool) {
+    const schema = encodeProtobufValue(tool.inputSchema ?? { type: "object" });
+    return concatBytes([
+        encodeStringField(1, tool.name),
+        encodeStringField(2, tool.description),
+        encodeBytesField(3, schema),
+        encodeStringField(4, "opencode"),
+        encodeStringField(5, tool.name),
+    ]);
+}
+export function encodeCursorMcpTools(tools) {
+    return concatBytes(tools.map((tool) => encodeBytesField(1, encodeMcpToolDefinition(tool))));
+}

package/dist/providers/cursor/models.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterModel } from "../../core/models";
+import { type CursorHttp2Post } from "./http2";
+export declare function parseCursorModelOutput(stdout: string): readonly AdapterModel[];
+export type CursorModelsRun = (agent: string, args: readonly string[], signal: AbortSignal) => Promise<{
+    readonly code: number;
+    readonly stdout: string;
+}>;
+export declare function listCursorModels(agent: string, signal: AbortSignal, run?: CursorModelsRun): Promise<readonly AdapterModel[]>;
+export declare function parseCursorUsableModels(body: Uint8Array): readonly AdapterModel[];
+export type CursorUsableModelsPost = (request: CursorHttp2Post) => Promise<{
+    readonly status: number;
+    readonly body: Uint8Array;
+}>;
+export declare function listCursorUsableModels(token: string, signal: AbortSignal, post?: CursorUsableModelsPost): Promise<readonly AdapterModel[]>;

package/dist/providers/cursor/models.js

@@ -0,0 +1,116 @@
+import { spawn } from "node:child_process";
+import { parseModelIdList } from "../../catalog/parse-ids";
+import { OperationCancelledError } from "../../core/errors";
+import { cursorHttp2Post } from "./http2";
+import { decodeFields, decodeUtf8 } from "./proto-wire";
+function stripAnsi(text) {
+    let output = "";
+    let index = 0;
+    while (index < text.length) {
+        if (text.charCodeAt(index) === 27 && text.at(index + 1) === "[") {
+            index += 2;
+            while (index < text.length && text.at(index) !== "m") {
+                index += 1;
+            }
+            index += 1;
+            continue;
+        }
+        output += text.at(index) ?? "";
+        index += 1;
+    }
+    return output;
+}
+export function parseCursorModelOutput(stdout) {
+    const text = stripAnsi(stdout).trim();
+    if (text.startsWith("{") || text.startsWith("[")) {
+        try {
+            return parseModelIdList(JSON.parse(text));
+        }
+        catch {
+            return [];
+        }
+    }
+    const ids = [];
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.toLowerCase().startsWith("available")) {
+            continue;
+        }
+        const separator = trimmed.indexOf(" - ");
+        const id = separator === -1 ? trimmed.split(/\s+/)[0] : trimmed.slice(0, separator).trim();
+        if (id !== undefined && id.length > 0) {
+            ids.push(id);
+        }
+    }
+    return parseModelIdList(ids);
+}
+function runCursorModelsCommand(agent, args, signal) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(agent, [...args], { signal, stdio: ["ignore", "pipe", "pipe"] });
+        const chunks = [];
+        child.stdout.on("data", (chunk) => {
+            chunks.push(chunk);
+        });
+        child.once("error", (error) => {
+            if (signal.aborted) {
+                reject(new OperationCancelledError("cursor-list-models"));
+                return;
+            }
+            reject(error);
+        });
+        child.once("close", (code) => {
+            if (signal.aborted) {
+                reject(new OperationCancelledError("cursor-list-models"));
+                return;
+            }
+            resolve({ code: code ?? 1, stdout: Buffer.concat(chunks).toString("utf8") });
+        });
+    });
+}
+export async function listCursorModels(agent, signal, run = runCursorModelsCommand) {
+    if (signal.aborted) {
+        throw new OperationCancelledError("cursor-list-models");
+    }
+    const attempts = [["models"], ["--list-models"]];
+    for (const args of attempts) {
+        const result = await run(agent, args, signal);
+        if (result.code !== 0) {
+            continue;
+        }
+        const models = parseCursorModelOutput(result.stdout);
+        if (models.length > 0) {
+            return models;
+        }
+    }
+    return [];
+}
+export function parseCursorUsableModels(body) {
+    const ids = [];
+    for (const model of decodeFields(body)) {
+        if (model.field !== 1) {
+            continue;
+        }
+        for (const inner of decodeFields(model.bytes)) {
+            if (inner.field === 1) {
+                ids.push(decodeUtf8(inner.bytes));
+            }
+        }
+    }
+    return parseModelIdList(ids);
+}
+export async function listCursorUsableModels(token, signal, post = cursorHttp2Post) {
+    if (signal.aborted) {
+        throw new OperationCancelledError("cursor-list-models");
+    }
+    const response = await post({
+        path: "/agent.v1.AgentService/GetUsableModels",
+        token,
+        body: new Uint8Array(),
+        headers: { "content-type": "application/proto", te: "trailers" },
+        signal,
+    });
+    if (response.status < 200 || response.status >= 300) {
+        return [];
+    }
+    return parseCursorUsableModels(response.body);
+}

package/dist/providers/cursor/ndjson.d.ts

@@ -0,0 +1,3 @@
+export declare function cursorTextFromUnknown(value: unknown): string | null;
+export declare function cursorResultError(value: object): Error | null;
+export declare function extractCursorNdjsonText(stream: string): string;