opencode-ext-connector 0.3.0

package/dist/providers/cursor/credentials.js

@@ -0,0 +1,22 @@
+// Derived from Rahularya01/pi-cursor src/auth/cli-credentials.ts.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+function stringField(value, key) {
+    if (!(key in value)) {
+        return null;
+    }
+    const field = Reflect.get(value, key);
+    return typeof field === "string" && field.length > 0 ? field : null;
+}
+export function parseCursorCredentials(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const accessToken = stringField(value, "accessToken");
+    if (accessToken === null) {
+        return null;
+    }
+    return {
+        accessToken,
+        refreshToken: stringField(value, "refreshToken"),
+    };
+}

package/dist/providers/cursor/direct-run-types.d.ts

@@ -0,0 +1,33 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+import type { Clock } from "../../core/clock";
+import type { CursorBridgeClient } from "./bridge-client";
+import type { CursorCheckpointStore } from "./checkpoint-store";
+import type { CursorMcpTool } from "./mcp-tools";
+import type { CursorRequestBlobOwnership } from "./request-blob-ownership";
+import type { CursorRunSessionRegistry } from "./run-session";
+import type { CursorSessionId, CursorSessionStateStore } from "./session-state";
+export type CursorDirectSetupCleanupResources = {
+    readonly checkpointStore: CursorCheckpointStore;
+    readonly ownership: CursorRequestBlobOwnership;
+    readonly sessionId: CursorSessionId;
+    readonly sessionStore: CursorSessionStateStore;
+};
+export type CursorDirectSetupCleanup = {
+    readonly releaseOwnership: () => void;
+    readonly invalidateCheckpoint: () => void;
+    readonly invalidateSession: () => void;
+};
+export type CursorDirectRunOptions = {
+    readonly bridge: CursorBridgeClient;
+    readonly call: LanguageModelV3CallOptions;
+    readonly clock: Clock;
+    readonly createId: () => string;
+    readonly createSetupCleanup?: (resources: CursorDirectSetupCleanupResources) => CursorDirectSetupCleanup;
+    readonly idleTimeoutMs: number;
+    readonly modelId: string;
+    readonly registry: CursorRunSessionRegistry;
+    readonly signal: AbortSignal;
+    readonly token: string;
+    readonly tools: readonly CursorMcpTool[];
+    readonly ttlMs: number;
+};

package/dist/providers/cursor/direct-run-types.js

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

package/dist/providers/cursor/direct-run.d.ts

@@ -0,0 +1,5 @@
+import type { CursorDirectRunOptions } from "./direct-run-types";
+import { type CursorStreamAdapter } from "./stream-adapter";
+export declare function startCursorDirectRun(options: CursorDirectRunOptions): Promise<{
+    readonly stream: CursorStreamAdapter["stream"];
+}>;

package/dist/providers/cursor/direct-run.js

@@ -0,0 +1,213 @@
+import { OperationCancelledError } from "../../core/errors";
+import { parseModelId } from "../../core/ids";
+import { createCursorBlobStore } from "./blob-store";
+import { createCursorCheckpointStore } from "./checkpoint-store";
+import { encodeConnectFrame } from "./connect-frame";
+import { consumeCursorDirectAttempt, isCursorRetryableStreamError } from "./direct-stream";
+import { cursorMcpDefinitions } from "./exec-reply";
+import { cursorPromptText } from "./prompt";
+import { createCursorIdleWatchdog, createCursorRecoveryPlanner } from "./recovery";
+import { buildCursorAgentRunRequest } from "./request-build";
+import { createCursorServerDispatcher } from "./server-dispatch";
+import { createCursorSessionStateStore, parseCursorSessionId } from "./session-state";
+import { settleCursorCleanup } from "./settle-cleanup";
+import { createCursorStreamAdapter } from "./stream-adapter";
+const CURSOR_RUN_PATH = "/agent.v1.AgentService/Run";
+function createLogicalRun(options) {
+    const sessionId = parseCursorSessionId(options.createId());
+    const blobStore = createCursorBlobStore({
+        clock: options.clock,
+        maxBytes: 16_777_216,
+        maxEntries: 1_024,
+        ttlMs: options.ttlMs,
+    });
+    const checkpointStore = createCursorCheckpointStore({
+        blobStore,
+        clock: options.clock,
+        maxBytes: 8_388_608,
+        maxEntries: 4,
+        ttlMs: options.ttlMs,
+    });
+    const sessionStore = createCursorSessionStateStore({
+        blobStore,
+        clock: options.clock,
+        maxKeysPerSession: 128,
+        maxSessions: 4,
+        ttlMs: options.ttlMs,
+    });
+    const placeholder = buildRequest(options, { blobStore, checkpointStore, sessionId }, "initial");
+    const cleanup = options.createSetupCleanup?.({
+        checkpointStore,
+        ownership: placeholder.ownership,
+        sessionId,
+        sessionStore,
+    }) ?? {
+        releaseOwnership: placeholder.ownership.release,
+        invalidateCheckpoint: () => checkpointStore.invalidate(sessionId),
+        invalidateSession: () => sessionStore.invalidate(sessionId),
+    };
+    placeholder.ownership.release();
+    return { adapter: createCursorStreamAdapter(), blobStore, checkpointStore, cleanup, sessionId };
+}
+function buildRequest(options, logical, mode) {
+    const common = {
+        conversationId: logical.sessionId,
+        history: [],
+        rootSystemPrompt: "",
+        mcpTools: cursorMcpDefinitions(options.tools),
+        modelId: parseModelId(options.modelId),
+        modelParameters: [],
+    };
+    return buildCursorAgentRunRequest({
+        blobStore: logical.blobStore,
+        checkpointStore: logical.checkpointStore,
+        createId: options.createId,
+        input: mode === "checkpoint"
+            ? {
+                ...common,
+                mode: "checkpoint",
+                sessionId: logical.sessionId,
+                action: { kind: "resume" },
+            }
+            : {
+                ...common,
+                mode: "fresh",
+                action: { kind: "user", text: cursorPromptText(options.call), images: [] },
+            },
+    });
+}
+async function openAttempt(options, logical, mode) {
+    const request = buildRequest(options, logical, mode);
+    let stream = null;
+    try {
+        stream = await options.bridge.open({
+            id: options.createId(),
+            accessToken: options.token,
+            path: CURSOR_RUN_PATH,
+            headers: { "content-type": "application/connect+proto", "connect-protocol-version": "1" },
+            signal: options.signal,
+        });
+        if (options.signal.aborted)
+            throw new OperationCancelledError("cursor-direct-stream");
+        await stream.write(encodeConnectFrame(request.bytes), options.signal);
+        if (options.signal.aborted)
+            throw new OperationCancelledError("cursor-direct-stream");
+        return options.registry.register({
+            sessionId: logical.sessionId,
+            modelId: options.modelId,
+            stream,
+            ownership: request.ownership,
+            dispatcher: createCursorServerDispatcher({
+                blobStore: logical.blobStore,
+                checkpointStore: logical.checkpointStore,
+                sessionId: logical.sessionId,
+                tools: options.tools,
+            }),
+            disposeStores: () => {
+                logical.cleanup.invalidateCheckpoint();
+                logical.cleanup.invalidateSession();
+            },
+        });
+    }
+    catch (error) {
+        try {
+            await settleCursorCleanup([
+                ...(stream === null ? [] : [stream.abort]),
+                request.ownership.release,
+            ]);
+        }
+        catch (cleanupError) {
+            const message = error instanceof Error ? error.message : "Cursor setup failed";
+            throw new AggregateError([error, cleanupError], message);
+        }
+        throw error;
+    }
+}
+async function failRun(logical, session, error) {
+    try {
+        if (session === null) {
+            logical.cleanup.invalidateCheckpoint();
+            logical.cleanup.invalidateSession();
+        }
+        else
+            await session.abort();
+    }
+    catch (cleanupError) {
+        logical.adapter.fail(new AggregateError([error, cleanupError], "Cursor recovery cleanup failed"));
+        return;
+    }
+    logical.adapter.fail(error);
+}
+export async function startCursorDirectRun(options) {
+    const logical = createLogicalRun(options);
+    const planner = createCursorRecoveryPlanner();
+    let session;
+    try {
+        session = await openAttempt(options, logical, "initial");
+    }
+    catch (error) {
+        logical.cleanup.releaseOwnership();
+        logical.cleanup.invalidateCheckpoint();
+        logical.cleanup.invalidateSession();
+        throw error;
+    }
+    void (async () => {
+        for (;;) {
+            const watchdog = createCursorIdleWatchdog({
+                clock: options.clock,
+                idleTimeoutMs: options.idleTimeoutMs,
+                parentSignal: options.signal,
+            });
+            try {
+                const exit = await consumeCursorDirectAttempt({
+                    session,
+                    signal: watchdog.signal,
+                    watchdog,
+                    adapter: logical.adapter,
+                });
+                watchdog.dispose();
+                if (exit.kind === "terminal")
+                    await options.registry.terminate(session.identity);
+                else
+                    session.touch();
+                logical.adapter.finish(exit.kind === "parked" ? "tool-calls" : "stop");
+                return;
+            }
+            catch (error) {
+                const idle = watchdog.expired();
+                watchdog.dispose();
+                if (options.signal.aborted) {
+                    await failRun(logical, session, new OperationCancelledError("cursor-direct-stream"));
+                    return;
+                }
+                const decision = planner.next({
+                    checkpointAvailable: logical.checkpointStore.resume(logical.sessionId) !== null,
+                    replay: logical.adapter.replayState(),
+                    retryable: idle || isCursorRetryableStreamError(error),
+                });
+                if (decision.kind === "fail") {
+                    try {
+                        planner.requireRetry(decision, error);
+                    }
+                    catch (recoveryError) {
+                        await failRun(logical, session, recoveryError);
+                    }
+                    return;
+                }
+                try {
+                    const retireForRetry = session.retireForRetry;
+                    if (retireForRetry === undefined)
+                        throw new TypeError("retry retirement is unavailable");
+                    await retireForRetry();
+                    logical.adapter.suspendForRetry();
+                    session = await openAttempt(options, logical, decision.mode);
+                }
+                catch (retryError) {
+                    await failRun(logical, session, retryError);
+                    return;
+                }
+            }
+        }
+    })();
+    return { stream: logical.adapter.stream };
+}

package/dist/providers/cursor/direct-runtime.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModelV3CallOptions, LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import type { Clock } from "../../core/clock";
+import { type CursorBridgeClient } from "./bridge-client";
+import type { CursorDirectSetupCleanup, CursorDirectSetupCleanupResources } from "./direct-run-types";
+import type { CursorRunSessionBackgroundCleanupErrorHandler } from "./run-session-expiry";
+export type { CursorDirectSetupCleanup, CursorDirectSetupCleanupResources, } from "./direct-run-types";
+export type CursorDirectRuntimeOptions = {
+    readonly clock: Clock;
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly onBackgroundCleanupError: CursorRunSessionBackgroundCleanupErrorHandler;
+    readonly createBridgeClient?: (signal: AbortSignal) => Promise<CursorBridgeClient>;
+    readonly createId?: () => string;
+    readonly ttlMs?: number;
+    readonly idleTimeoutMs?: number;
+    readonly createSetupCleanup?: (resources: CursorDirectSetupCleanupResources) => CursorDirectSetupCleanup;
+};
+export type CursorDirectRuntime = {
+    readonly doStream: (call: LanguageModelV3CallOptions, modelId: string) => Promise<{
+        readonly stream: ReadableStream<LanguageModelV3StreamPart>;
+    }>;
+    readonly dispose: () => Promise<void>;
+};
+export declare function createCursorDirectRuntime(options: CursorDirectRuntimeOptions): CursorDirectRuntime;

package/dist/providers/cursor/direct-runtime.js

@@ -0,0 +1,111 @@
+import { randomUUID } from "node:crypto";
+import { AdapterError, OperationCancelledError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { createAsyncDisposable } from "../../core/lifecycle";
+import { createCursorBridgeClient } from "./bridge-client";
+import { startCursorDirectRun } from "./direct-run";
+import { consumeCursorDirectSession } from "./direct-stream";
+import { createCursorRunSessionRegistry } from "./run-session";
+import { settleCursorCleanup } from "./settle-cleanup";
+import { buildCursorToolContinuations } from "./tool-continuation";
+function toolsFromCall(call) {
+    return (call.tools ?? [])
+        .filter((tool) => tool.type === "function")
+        .map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? "",
+        inputSchema: tool.inputSchema,
+    }));
+}
+function cursorFailure(operation) {
+    return new AdapterError({
+        operation,
+        retryable: false,
+        cause: null,
+        providerId: parseProviderId("cursor"),
+    });
+}
+export function createCursorDirectRuntime(options) {
+    const lifecycle = new AbortController();
+    const createId = options.createId ?? randomUUID;
+    const registry = createCursorRunSessionRegistry({
+        clock: options.clock,
+        ttlMs: options.ttlMs ?? 300_000,
+        onBackgroundCleanupError: options.onBackgroundCleanupError,
+    });
+    let bridgeClient = null;
+    const bridge = () => {
+        bridgeClient ??=
+            options.createBridgeClient?.(lifecycle.signal) ??
+                createCursorBridgeClient({ signal: lifecycle.signal });
+        return bridgeClient;
+    };
+    const doStream = async (call, modelId) => {
+        const signal = call.abortSignal ?? new AbortController().signal;
+        if (signal.aborted)
+            throw new OperationCancelledError("cursor-direct-stream");
+        const resultCallIds = [];
+        for (let index = call.prompt.length - 1; index >= 0; index -= 1) {
+            const message = call.prompt[index];
+            if (message?.role !== "tool")
+                break;
+            resultCallIds.unshift(...message.content
+                .filter((part) => part.type === "tool-result")
+                .map((part) => part.toolCallId));
+        }
+        if (resultCallIds.length > 0) {
+            const existing = registry.resolveParkedCalls(resultCallIds, modelId);
+            const continuations = buildCursorToolContinuations(call.prompt, existing.dispatcher.parkedCalls);
+            await existing.writeContinuations(continuations, signal);
+            return { stream: await consumeCursorDirectSession({ session: existing, signal, registry }) };
+        }
+        const setup = new AbortController();
+        const cancel = () => {
+            if (!setup.signal.aborted) {
+                setup.abort(new OperationCancelledError("cursor-direct-stream"));
+            }
+        };
+        lifecycle.signal.addEventListener("abort", cancel, { once: true });
+        call.abortSignal?.addEventListener("abort", cancel, { once: true });
+        if (lifecycle.signal.aborted || signal.aborted)
+            cancel();
+        try {
+            const token = await options.readAccessToken(setup.signal);
+            if (setup.signal.aborted)
+                throw new OperationCancelledError("cursor-direct-stream");
+            if (token === null)
+                throw cursorFailure("cursor-auth-unavailable");
+            return await startCursorDirectRun({
+                bridge: await bridge(),
+                call,
+                clock: options.clock,
+                createId,
+                idleTimeoutMs: options.idleTimeoutMs ?? 60_000,
+                modelId,
+                registry,
+                signal,
+                token,
+                tools: toolsFromCall(call),
+                ttlMs: options.ttlMs ?? 300_000,
+                ...(options.createSetupCleanup === undefined
+                    ? {}
+                    : { createSetupCleanup: options.createSetupCleanup }),
+            });
+        }
+        finally {
+            lifecycle.signal.removeEventListener("abort", cancel);
+            call.abortSignal?.removeEventListener("abort", cancel);
+        }
+    };
+    const disposal = createAsyncDisposable(async () => {
+        lifecycle.abort();
+        await settleCursorCleanup([
+            registry.dispose,
+            async () => {
+                const client = await bridgeClient;
+                await client?.dispose();
+            },
+        ]);
+    });
+    return { doStream, dispose: disposal.dispose };
+}

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

@@ -0,0 +1,28 @@
+import type { CursorIdleWatchdog } from "./recovery";
+import type { CursorRunSession, CursorRunSessionRegistry } from "./run-session";
+import { type CursorStreamAdapter } from "./stream-adapter";
+export { createConnectFrameStreamDecoder } from "./connect-frame-stream";
+export type CursorDirectAttemptExit = {
+    readonly kind: "terminal";
+} | {
+    readonly kind: "parked";
+};
+export declare function consumeCursorDirectAttempt(options: {
+    readonly session: CursorRunSession;
+    readonly signal: AbortSignal;
+    readonly watchdog: CursorIdleWatchdog;
+    readonly adapter: CursorStreamAdapter;
+}): Promise<CursorDirectAttemptExit>;
+export declare function consumeCursorDirectSession(options: {
+    readonly session: CursorRunSession;
+    readonly signal: AbortSignal;
+    readonly registry: CursorRunSessionRegistry;
+}): Promise<CursorStreamAdapter["stream"]>;
+export declare function isCursorRetryableStreamError(error: unknown): boolean;
+export declare class CursorDirectStreamError extends Error {
+    readonly bridgeCode: string;
+    readonly bridgeMessage?: string | undefined;
+    readonly name = "CursorDirectStreamError";
+    readonly code = "CURSOR_DIRECT_STREAM_ERROR";
+    constructor(bridgeCode: string, bridgeMessage?: string | undefined);
+}

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

@@ -0,0 +1,190 @@
+import { createConnectFrameStreamDecoder, } from "./connect-frame-stream";
+import { annotateCursorProtocolFailure } from "./protocol-failure";
+import { createCursorStreamAdapter } from "./stream-adapter";
+export { createConnectFrameStreamDecoder } from "./connect-frame-stream";
+function finishConnectDecoder(decoder) {
+    try {
+        decoder.finish();
+    }
+    catch (error) {
+        annotateCursorProtocolFailure(error, "connect-frame");
+    }
+}
+function assertNoStranding(results, session) {
+    const stranded = results.find((result) => result.outcome.kind === "drift" && result.outcome.stranding);
+    if (stranded?.outcome.kind === "drift") {
+        session.dispatcher.parkedCalls.clear();
+        throw new CursorDirectStreamError(`stranding-drift:${stranded.outcome.detail}`);
+    }
+}
+async function applyDispatch(options) {
+    for (const reply of options.result.replyFrames) {
+        await options.session.write(reply, options.signal);
+    }
+    const outcome = options.result.outcome;
+    if (outcome.kind === "heartbeat") {
+        options.watchdog.heartbeat();
+        return null;
+    }
+    options.watchdog.progress();
+    switch (outcome.kind) {
+        case "text":
+        case "thinking":
+            options.adapter.emit(outcome);
+            return null;
+        case "checkpoint":
+            if (outcome.stored)
+                options.adapter.noteCheckpoint();
+            return null;
+        case "turn-ended":
+            return { kind: "terminal" };
+        case "mcp-parked":
+            options.adapter.emit(outcome);
+            options.watchdog.park();
+            return { kind: "parked" };
+        case "control":
+            throw new CursorDirectStreamError("server-abort");
+        case "drift":
+            if (outcome.stranding)
+                throw new CursorDirectStreamError("stranding-drift");
+            return null;
+        default:
+            return null;
+    }
+}
+export async function consumeCursorDirectAttempt(options) {
+    const decoder = createConnectFrameStreamDecoder();
+    let terminalSeen = false;
+    for (;;) {
+        const event = await options.session.stream.nextEvent(options.signal);
+        if (event.kind === "error")
+            throw new CursorDirectStreamError(event.code, event.message);
+        if (event.kind === "headers" && (event.status < 200 || event.status >= 300)) {
+            throw new CursorDirectStreamError(`http-${event.status}`);
+        }
+        if (event.kind === "trailers") {
+            const status = event.headers["connect-status"];
+            if (status !== undefined && status !== "0") {
+                throw new CursorDirectStreamError(`connect-status-${status}`);
+            }
+            terminalSeen = status === "0" || terminalSeen;
+            continue;
+        }
+        if (event.kind === "end") {
+            finishConnectDecoder(decoder);
+            if (!terminalSeen)
+                throw new CursorDirectStreamError("premature-end");
+            return { kind: "terminal" };
+        }
+        if (event.kind !== "data")
+            continue;
+        let frames;
+        try {
+            frames = decoder.push(event.payload);
+        }
+        catch (error) {
+            annotateCursorProtocolFailure(error, "connect-frame");
+        }
+        let results;
+        try {
+            results = frames
+                .filter((frame) => frame.kind === "message")
+                .map((frame) => options.session.dispatcher.dispatchBytes(frame.bytes));
+        }
+        catch (error) {
+            annotateCursorProtocolFailure(error, "server-dispatch");
+        }
+        assertNoStranding(results, options.session);
+        for (const [index, frame] of frames.entries()) {
+            if (frame.kind === "end") {
+                if (frame.error !== null) {
+                    throw new CursorDirectStreamError(frame.error.code, frame.error.message);
+                }
+                terminalSeen = true;
+                continue;
+            }
+            const result = results.shift();
+            if (result === undefined)
+                throw new CursorDirectStreamError("missing-dispatch-result");
+            const exit = await applyDispatch({ ...options, result });
+            if (exit?.kind === "terminal") {
+                if (index !== frames.length - 1) {
+                    const trailingFrame = frames.at(index + 1);
+                    if (frames.length - index !== 2 || trailingFrame?.kind !== "end") {
+                        throw new CursorDirectStreamError("trailing-frame-after-turn-ended");
+                    }
+                    if (trailingFrame.error !== null) {
+                        throw new CursorDirectStreamError(trailingFrame.error.code, trailingFrame.error.message);
+                    }
+                }
+                finishConnectDecoder(decoder);
+                return exit;
+            }
+            if (exit !== null)
+                return exit;
+        }
+        if (terminalSeen)
+            return { kind: "terminal" };
+    }
+}
+export async function consumeCursorDirectSession(options) {
+    const adapter = createCursorStreamAdapter();
+    const watchdog = {
+        signal: options.signal,
+        expired: () => false,
+        progress: () => undefined,
+        heartbeat: () => undefined,
+        park: () => undefined,
+        dispose: () => undefined,
+    };
+    void consumeCursorDirectAttempt({ ...options, watchdog, adapter }).then(async (exit) => {
+        if (exit.kind === "terminal")
+            await options.registry.terminate(options.session.identity);
+        else
+            options.session.touch();
+        adapter.finish(exit.kind === "parked" ? "tool-calls" : "stop");
+    }, async (error) => {
+        try {
+            await options.session.abort();
+        }
+        catch (cleanupError) {
+            adapter.fail(new AggregateError([error, cleanupError], "Cursor direct stream failure and abort cleanup failure"));
+            return;
+        }
+        adapter.fail(error);
+    });
+    return adapter.stream;
+}
+export function isCursorRetryableStreamError(error) {
+    if (!(error instanceof CursorDirectStreamError))
+        return false;
+    if (error.bridgeCode === "premature-end")
+        return true;
+    if ([
+        "stream-error",
+        "stream-unavailable",
+        "session-error",
+        "session-goaway",
+        "session-ping-error",
+    ].includes(error.bridgeCode))
+        return true;
+    if (error.bridgeCode.startsWith("http-")) {
+        const status = Number(error.bridgeCode.slice(5));
+        return status === 408 || status === 429 || status >= 500;
+    }
+    if (error.bridgeCode.startsWith("connect-status-")) {
+        return ["4", "8", "13", "14"].includes(error.bridgeCode.slice(15));
+    }
+    return false;
+}
+export class CursorDirectStreamError extends Error {
+    bridgeCode;
+    bridgeMessage;
+    name = "CursorDirectStreamError";
+    code = "CURSOR_DIRECT_STREAM_ERROR";
+    constructor(bridgeCode, bridgeMessage) {
+        super(bridgeMessage ?? "Cursor direct stream failed");
+        this.bridgeCode = bridgeCode;
+        this.bridgeMessage = bridgeMessage;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { CursorMcpTool } from "./mcp-tools";
+import type { ExecServerMessage } from "./proto/exec";
+import type { McpToolDefinition } from "./proto/mcp";
+import { type AgentClientMessage } from "./proto/request";
+export declare function cursorMcpDefinitions(tools: readonly CursorMcpTool[]): readonly McpToolDefinition[];
+export declare function encodeCursorClientFrame(message: AgentClientMessage): Uint8Array;
+export declare function encodeRequestContextFrame(message: Extract<ExecServerMessage, {
+    readonly kind: "request-context-args";
+}>, tools: readonly CursorMcpTool[]): Uint8Array;
+export declare function encodeNativeRejectFrame(message: Extract<ExecServerMessage, {
+    readonly kind: "native";
+}>): Uint8Array;
+export declare function cursorServerReplies(bytes: Uint8Array, tools: readonly CursorMcpTool[]): readonly Uint8Array[];