@playwo/opencode-cursor-oauth 0.0.0-dev.1b946f85e9b0 → 0.0.0-dev.2a59bf1639ea

package/dist/proxy/stream-dispatch.js

@@ -0,0 +1,491 @@
+import { create, toBinary } from "@bufbuild/protobuf";
+import { AgentClientMessageSchema, ClientHeartbeatSchema, ConversationStateStructureSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpResultSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "../proto/agent_pb";
+import { CONNECT_END_STREAM_FLAG } from "../cursor/config";
+import { logPluginError, logPluginWarn } from "../logger";
+import { decodeMcpArgsMap } from "../openai/tools";
+export function parseConnectEndStream(data) {
+    try {
+        const payload = JSON.parse(new TextDecoder().decode(data));
+        const error = payload?.error;
+        if (error) {
+            const code = error.code ?? "unknown";
+            const message = error.message ?? "Unknown error";
+            return new Error(`Connect error ${code}: ${message}`);
+        }
+        return null;
+    }
+    catch {
+        return new Error("Failed to parse Connect end stream");
+    }
+}
+export function makeHeartbeatBytes() {
+    const heartbeat = create(AgentClientMessageSchema, {
+        message: {
+            case: "clientHeartbeat",
+            value: create(ClientHeartbeatSchema, {}),
+        },
+    });
+    return toBinary(AgentClientMessageSchema, heartbeat);
+}
+export function scheduleBridgeEnd(bridge) {
+    queueMicrotask(() => {
+        if (bridge.alive)
+            bridge.end();
+    });
+}
+/**
+ * Create a stateful parser for Connect protocol frames.
+ * Handles buffering partial data across chunks.
+ */
+export function createConnectFrameParser(onMessage, onEndStream) {
+    let pending = Buffer.alloc(0);
+    return (incoming) => {
+        pending = Buffer.concat([pending, incoming]);
+        while (pending.length >= 5) {
+            const flags = pending[0];
+            const msgLen = pending.readUInt32BE(1);
+            if (pending.length < 5 + msgLen)
+                break;
+            const messageBytes = pending.subarray(5, 5 + msgLen);
+            pending = pending.subarray(5 + msgLen);
+            if (flags & CONNECT_END_STREAM_FLAG) {
+                onEndStream(messageBytes);
+            }
+            else {
+                onMessage(messageBytes);
+            }
+        }
+    };
+}
+const THINKING_TAG_NAMES = [
+    "think",
+    "thinking",
+    "reasoning",
+    "thought",
+    "think_intent",
+];
+const MAX_THINKING_TAG_LEN = 16; // </think_intent> is 15 chars
+/**
+ * Strip thinking tags from streamed text, routing tagged content to reasoning.
+ * Buffers partial tags across chunk boundaries.
+ */
+export function createThinkingTagFilter() {
+    let buffer = "";
+    let inThinking = false;
+    return {
+        process(text) {
+            const input = buffer + text;
+            buffer = "";
+            let content = "";
+            let reasoning = "";
+            let lastIdx = 0;
+            const re = new RegExp(`<(/?)(?:${THINKING_TAG_NAMES.join("|")})\\s*>`, "gi");
+            let match;
+            while ((match = re.exec(input)) !== null) {
+                const before = input.slice(lastIdx, match.index);
+                if (inThinking)
+                    reasoning += before;
+                else
+                    content += before;
+                inThinking = match[1] !== "/";
+                lastIdx = re.lastIndex;
+            }
+            const rest = input.slice(lastIdx);
+            // Buffer a trailing '<' that could be the start of a thinking tag.
+            const ltPos = rest.lastIndexOf("<");
+            if (ltPos >= 0 &&
+                rest.length - ltPos < MAX_THINKING_TAG_LEN &&
+                /^<\/?[a-z_]*$/i.test(rest.slice(ltPos))) {
+                buffer = rest.slice(ltPos);
+                const before = rest.slice(0, ltPos);
+                if (inThinking)
+                    reasoning += before;
+                else
+                    content += before;
+            }
+            else {
+                if (inThinking)
+                    reasoning += rest;
+                else
+                    content += rest;
+            }
+            return { content, reasoning };
+        },
+        flush() {
+            const b = buffer;
+            buffer = "";
+            if (!b)
+                return { content: "", reasoning: "" };
+            return inThinking
+                ? { content: "", reasoning: b }
+                : { content: b, reasoning: "" };
+        },
+    };
+}
+export function computeUsage(state) {
+    const completion_tokens = state.outputTokens;
+    const total_tokens = state.totalTokens || completion_tokens;
+    const prompt_tokens = Math.max(0, total_tokens - completion_tokens);
+    return { prompt_tokens, completion_tokens, total_tokens };
+}
+export function processServerMessage(msg, blobStore, mcpTools, sendFrame, state, onText, onMcpExec, onCheckpoint, onTurnEnded, onUnsupportedMessage, onUnhandledExec) {
+    const msgCase = msg.message.case;
+    if (msgCase === "interactionUpdate") {
+        handleInteractionUpdate(msg.message.value, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage);
+    }
+    else if (msgCase === "kvServerMessage") {
+        handleKvMessage(msg.message.value, blobStore, sendFrame);
+    }
+    else if (msgCase === "execServerMessage") {
+        handleExecMessage(msg.message.value, mcpTools, sendFrame, onMcpExec, onUnhandledExec);
+    }
+    else if (msgCase === "execServerControlMessage") {
+        onUnsupportedMessage?.({
+            category: "execServerControl",
+            caseName: msg.message.value.message.case ?? "undefined",
+        });
+    }
+    else if (msgCase === "interactionQuery") {
+        onUnsupportedMessage?.({
+            category: "interactionQuery",
+            caseName: msg.message.value.query.case ?? "undefined",
+        });
+    }
+    else if (msgCase === "conversationCheckpointUpdate") {
+        const stateStructure = msg.message.value;
+        if (stateStructure.tokenDetails) {
+            state.totalTokens = stateStructure.tokenDetails.usedTokens;
+        }
+        if (onCheckpoint) {
+            onCheckpoint(toBinary(ConversationStateStructureSchema, stateStructure));
+        }
+    }
+    else {
+        onUnsupportedMessage?.({
+            category: "agentMessage",
+            caseName: msgCase ?? "undefined",
+        });
+    }
+}
+function handleInteractionUpdate(update, state, onText, onMcpExec, onTurnEnded, onUnsupportedMessage) {
+    const updateCase = update.message?.case;
+    if (updateCase === "textDelta") {
+        const delta = update.message.value.text || "";
+        if (delta)
+            onText(delta, false);
+    }
+    else if (updateCase === "thinkingDelta") {
+        const delta = update.message.value.text || "";
+        if (delta)
+            onText(delta, true);
+    }
+    else if (updateCase === "tokenDelta") {
+        state.outputTokens += update.message.value.tokens ?? 0;
+    }
+    else if (updateCase === "partialToolCall") {
+        const partial = update.message.value;
+        if (partial.callId && partial.argsTextDelta) {
+            state.interactionToolArgsText.set(partial.callId, partial.argsTextDelta);
+        }
+    }
+    else if (updateCase === "toolCallCompleted") {
+        const exec = decodeInteractionToolCall(update.message.value, state);
+        if (exec)
+            onMcpExec(exec);
+        else {
+            onUnsupportedMessage?.({
+                category: "toolCall",
+                caseName: update.message.value?.toolCall?.tool?.case ?? "undefined",
+                detail: "toolCallCompleted",
+            });
+        }
+    }
+    else if (updateCase === "turnEnded") {
+        onTurnEnded?.();
+    }
+    else if (updateCase === "toolCallStarted" ||
+        updateCase === "toolCallDelta" ||
+        updateCase === "thinkingCompleted" ||
+        updateCase === "userMessageAppended" ||
+        updateCase === "summary" ||
+        updateCase === "summaryStarted" ||
+        updateCase === "summaryCompleted" ||
+        updateCase === "heartbeat" ||
+        updateCase === "stepStarted" ||
+        updateCase === "stepCompleted") {
+        return;
+    }
+    else {
+        onUnsupportedMessage?.({
+            category: "interactionUpdate",
+            caseName: updateCase ?? "undefined",
+        });
+    }
+    // toolCallStarted, partialToolCall, toolCallDelta, toolCallCompleted
+    // are intentionally ignored. MCP tool calls flow through the exec
+    // message path (mcpArgs → mcpResult), not interaction updates.
+}
+function decodeInteractionToolCall(update, state) {
+    const callId = update.callId ?? "";
+    const toolCase = update.toolCall?.tool?.case;
+    if (toolCase !== "mcpToolCall")
+        return null;
+    const mcpArgs = update.toolCall?.tool?.value?.args;
+    if (!mcpArgs)
+        return null;
+    const toolCallId = mcpArgs.toolCallId || callId || crypto.randomUUID();
+    if (state.emittedToolCallIds.has(toolCallId))
+        return null;
+    const decodedMap = decodeMcpArgsMap(mcpArgs.args ?? {});
+    const partialArgsText = callId
+        ? state.interactionToolArgsText.get(callId)?.trim()
+        : undefined;
+    let decodedArgs = "{}";
+    if (Object.keys(decodedMap).length > 0) {
+        decodedArgs = JSON.stringify(decodedMap);
+    }
+    else if (partialArgsText) {
+        decodedArgs = partialArgsText;
+    }
+    state.emittedToolCallIds.add(toolCallId);
+    if (callId)
+        state.interactionToolArgsText.delete(callId);
+    return {
+        execId: callId || toolCallId,
+        execMsgId: 0,
+        toolCallId,
+        toolName: mcpArgs.toolName || mcpArgs.name || "unknown_mcp_tool",
+        decodedArgs,
+    };
+}
+/** Send a KV client response back to Cursor. */
+function sendKvResponse(kvMsg, messageCase, value, sendFrame) {
+    const response = create(KvClientMessageSchema, {
+        id: kvMsg.id,
+        message: { case: messageCase, value: value },
+    });
+    const clientMsg = create(AgentClientMessageSchema, {
+        message: { case: "kvClientMessage", value: response },
+    });
+    sendFrame(toBinary(AgentClientMessageSchema, clientMsg));
+}
+function handleKvMessage(kvMsg, blobStore, sendFrame) {
+    const kvCase = kvMsg.message.case;
+    if (kvCase === "getBlobArgs") {
+        const blobId = kvMsg.message.value.blobId;
+        const blobIdKey = Buffer.from(blobId).toString("hex");
+        const blobData = blobStore.get(blobIdKey);
+        if (!blobData) {
+            logPluginWarn("Cursor requested missing blob", {
+                blobId: blobIdKey,
+                knownBlobCount: blobStore.size,
+            });
+        }
+        sendKvResponse(kvMsg, "getBlobResult", create(GetBlobResultSchema, blobData ? { blobData } : {}), sendFrame);
+    }
+    else if (kvCase === "setBlobArgs") {
+        const { blobId, blobData } = kvMsg.message.value;
+        blobStore.set(Buffer.from(blobId).toString("hex"), blobData);
+        sendKvResponse(kvMsg, "setBlobResult", create(SetBlobResultSchema, {}), sendFrame);
+    }
+}
+function handleExecMessage(execMsg, mcpTools, sendFrame, onMcpExec, onUnhandledExec) {
+    const execCase = execMsg.message.case;
+    if (execCase === "requestContextArgs") {
+        const requestContext = create(RequestContextSchema, {
+            rules: [],
+            repositoryInfo: [],
+            tools: mcpTools,
+            gitRepos: [],
+            projectLayouts: [],
+            mcpInstructions: [],
+            fileContents: {},
+            customSubagents: [],
+        });
+        const result = create(RequestContextResultSchema, {
+            result: {
+                case: "success",
+                value: create(RequestContextSuccessSchema, { requestContext }),
+            },
+        });
+        sendExecResult(execMsg, "requestContextResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "mcpArgs") {
+        const mcpArgs = execMsg.message.value;
+        const decoded = decodeMcpArgsMap(mcpArgs.args ?? {});
+        onMcpExec({
+            execId: execMsg.execId,
+            execMsgId: execMsg.id,
+            toolCallId: mcpArgs.toolCallId || crypto.randomUUID(),
+            toolName: mcpArgs.toolName || mcpArgs.name,
+            decodedArgs: JSON.stringify(decoded),
+        });
+        return;
+    }
+    // --- Reject native Cursor tools ---
+    // The model tries these first. We must respond with rejection/error
+    // so it falls back to our MCP tools (registered via RequestContext).
+    const REJECT_REASON = "Tool not available in this environment. Use the MCP tools provided instead.";
+    if (execCase === "readArgs") {
+        const args = execMsg.message.value;
+        const result = create(ReadResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(ReadRejectedSchema, {
+                    path: args.path,
+                    reason: REJECT_REASON,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "readResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "lsArgs") {
+        const args = execMsg.message.value;
+        const result = create(LsResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(LsRejectedSchema, {
+                    path: args.path,
+                    reason: REJECT_REASON,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "lsResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "grepArgs") {
+        const result = create(GrepResultSchema, {
+            result: {
+                case: "error",
+                value: create(GrepErrorSchema, { error: REJECT_REASON }),
+            },
+        });
+        sendExecResult(execMsg, "grepResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "writeArgs") {
+        const args = execMsg.message.value;
+        const result = create(WriteResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(WriteRejectedSchema, {
+                    path: args.path,
+                    reason: REJECT_REASON,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "writeResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "deleteArgs") {
+        const args = execMsg.message.value;
+        const result = create(DeleteResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(DeleteRejectedSchema, {
+                    path: args.path,
+                    reason: REJECT_REASON,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "deleteResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "shellArgs" || execCase === "shellStreamArgs") {
+        const args = execMsg.message.value;
+        const result = create(ShellResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(ShellRejectedSchema, {
+                    command: args.command ?? "",
+                    workingDirectory: args.workingDirectory ?? "",
+                    reason: REJECT_REASON,
+                    isReadonly: false,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "shellResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "backgroundShellSpawnArgs") {
+        const args = execMsg.message.value;
+        const result = create(BackgroundShellSpawnResultSchema, {
+            result: {
+                case: "rejected",
+                value: create(ShellRejectedSchema, {
+                    command: args.command ?? "",
+                    workingDirectory: args.workingDirectory ?? "",
+                    reason: REJECT_REASON,
+                    isReadonly: false,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "backgroundShellSpawnResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "writeShellStdinArgs") {
+        const result = create(WriteShellStdinResultSchema, {
+            result: {
+                case: "error",
+                value: create(WriteShellStdinErrorSchema, { error: REJECT_REASON }),
+            },
+        });
+        sendExecResult(execMsg, "writeShellStdinResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "fetchArgs") {
+        const args = execMsg.message.value;
+        const result = create(FetchResultSchema, {
+            result: {
+                case: "error",
+                value: create(FetchErrorSchema, {
+                    url: args.url ?? "",
+                    error: REJECT_REASON,
+                }),
+            },
+        });
+        sendExecResult(execMsg, "fetchResult", result, sendFrame);
+        return;
+    }
+    if (execCase === "diagnosticsArgs") {
+        const result = create(DiagnosticsResultSchema, {});
+        sendExecResult(execMsg, "diagnosticsResult", result, sendFrame);
+        return;
+    }
+    // MCP resource/screen/computer exec types
+    const miscCaseMap = {
+        listMcpResourcesExecArgs: "listMcpResourcesExecResult",
+        readMcpResourceExecArgs: "readMcpResourceExecResult",
+        recordScreenArgs: "recordScreenResult",
+        computerUseArgs: "computerUseResult",
+    };
+    const resultCase = miscCaseMap[execCase];
+    if (resultCase) {
+        sendExecResult(execMsg, resultCase, create(McpResultSchema, {}), sendFrame);
+        return;
+    }
+    logPluginError("Unhandled Cursor exec type", {
+        execCase: execCase ?? "undefined",
+        execId: execMsg.execId,
+        execMsgId: execMsg.id,
+    });
+    onUnhandledExec?.({
+        execCase: execCase ?? "undefined",
+        execId: execMsg.execId,
+        execMsgId: execMsg.id,
+    });
+}
+/** Send an exec client message back to Cursor. */
+function sendExecResult(execMsg, messageCase, value, sendFrame) {
+    const execClientMessage = create(ExecClientMessageSchema, {
+        id: execMsg.id,
+        execId: execMsg.execId,
+        message: { case: messageCase, value: value },
+    });
+    const clientMessage = create(AgentClientMessageSchema, {
+        message: { case: "execClientMessage", value: execClientMessage },
+    });
+    sendFrame(toBinary(AgentClientMessageSchema, clientMessage));
+}

package/dist/proxy/stream-state.d.ts

@@ -0,0 +1,9 @@
+import type { PendingExec } from "./types";
+export interface StreamState {
+    toolCallIndex: number;
+    pendingExecs: PendingExec[];
+    outputTokens: number;
+    totalTokens: number;
+    interactionToolArgsText: Map<string, string>;
+    emittedToolCallIds: Set<string>;
+}

package/dist/proxy/stream-state.js

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

package/dist/proxy/title.d.ts

@@ -0,0 +1 @@
+export declare function handleTitleGenerationRequest(sourceText: string, accessToken: string, modelId: string, stream: boolean): Promise<Response>;

package/dist/proxy/title.js

@@ -0,0 +1,103 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { NameAgentRequestSchema, NameAgentResponseSchema, } from "../proto/agent_pb";
+import { callCursorUnaryRpc, decodeConnectUnaryBody } from "../cursor";
+import { SSE_HEADERS } from "./sse";
+function deriveFallbackTitle(text) {
+    const cleaned = text
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\[[^\]]+\]/g, " ")
+        .replace(/[^\p{L}\p{N}'’\-\s]+/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!cleaned)
+        return "";
+    const words = cleaned.split(" ").filter(Boolean).slice(0, 6);
+    return finalizeTitle(words.map(titleCaseWord).join(" "));
+}
+function titleCaseWord(word) {
+    if (!word)
+        return word;
+    return word[0].toUpperCase() + word.slice(1);
+}
+function finalizeTitle(value) {
+    return value
+        .replace(/^#{1,6}\s*/, "")
+        .replace(/[.!?,:;]+$/g, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 80)
+        .trim();
+}
+function createBufferedSSETextResponse(modelId, text, usage) {
+    const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+    const created = Math.floor(Date.now() / 1000);
+    const payload = [
+        {
+            id: completionId,
+            object: "chat.completion.chunk",
+            created,
+            model: modelId,
+            choices: [{ index: 0, delta: { content: text }, finish_reason: null }],
+        },
+        {
+            id: completionId,
+            object: "chat.completion.chunk",
+            created,
+            model: modelId,
+            choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        },
+        {
+            id: completionId,
+            object: "chat.completion.chunk",
+            created,
+            model: modelId,
+            choices: [],
+            usage,
+        },
+    ]
+        .map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`)
+        .join("") + "data: [DONE]\n\n";
+    return new Response(payload, { headers: SSE_HEADERS });
+}
+export async function handleTitleGenerationRequest(sourceText, accessToken, modelId, stream) {
+    const requestBody = toBinary(NameAgentRequestSchema, create(NameAgentRequestSchema, {
+        userMessage: sourceText,
+    }));
+    const response = await callCursorUnaryRpc({
+        accessToken,
+        rpcPath: "/agent.v1.AgentService/NameAgent",
+        requestBody,
+        timeoutMs: 5_000,
+    });
+    if (response.timedOut) {
+        throw new Error("Cursor title generation timed out");
+    }
+    if (response.exitCode !== 0) {
+        throw new Error(`Cursor title generation failed with HTTP ${response.exitCode}`);
+    }
+    const payload = decodeConnectUnaryBody(response.body) ?? response.body;
+    const decoded = fromBinary(NameAgentResponseSchema, payload);
+    const title = finalizeTitle(decoded.name) ||
+        deriveFallbackTitle(sourceText) ||
+        "Untitled Session";
+    const usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    if (stream) {
+        return createBufferedSSETextResponse(modelId, title, usage);
+    }
+    const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
+    const created = Math.floor(Date.now() / 1000);
+    return new Response(JSON.stringify({
+        id: completionId,
+        object: "chat.completion",
+        created,
+        model: modelId,
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: title },
+                finish_reason: "stop",
+            },
+        ],
+        usage,
+    }), { headers: { "Content-Type": "application/json" } });
+}

package/dist/proxy/types.d.ts

@@ -0,0 +1,27 @@
+import type { CursorSession } from "../cursor/bidi-session";
+import type { ConversationRequestMetadata } from "./conversation-meta";
+import type { McpToolDefinition } from "../proto/agent_pb";
+export interface CursorRequestPayload {
+    requestBytes: Uint8Array;
+    blobStore: Map<string, Uint8Array>;
+    mcpTools: McpToolDefinition[];
+}
+/** A pending tool execution waiting for results from the caller. */
+export interface PendingExec {
+    execId: string;
+    execMsgId: number;
+    toolCallId: string;
+    toolName: string;
+    /** Decoded arguments JSON string for SSE tool_calls emission. */
+    decodedArgs: string;
+}
+/** A live Cursor session kept alive across requests for tool result continuation. */
+export interface ActiveBridge {
+    bridge: CursorSession;
+    heartbeatTimer: NodeJS.Timeout;
+    blobStore: Map<string, Uint8Array>;
+    mcpTools: McpToolDefinition[];
+    pendingExecs: PendingExec[];
+    modelId: string;
+    metadata: ConversationRequestMetadata;
+}

package/dist/proxy/types.js

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

package/dist/proxy.d.ts

@@ -1,20 +1,2 @@
-interface CursorUnaryRpcOptions {
-    accessToken: string;
-    rpcPath: string;
-    requestBody: Uint8Array;
-    url?: string;
-    timeoutMs?: number;
-    transport?: "auto" | "fetch" | "http2";
-}
-export declare function callCursorUnaryRpc(options: CursorUnaryRpcOptions): Promise<{
-    body: Uint8Array;
-    exitCode: number;
-    timedOut: boolean;
-}>;
-export declare function getProxyPort(): number | undefined;
-export declare function startProxy(getAccessToken: () => Promise<string>, models?: ReadonlyArray<{
-    id: string;
-    name: string;
-}>): Promise<number>;
-export declare function stopProxy(): void;
-export {};
+export { getProxyPort, startProxy, stopProxy } from "./proxy/index";
+export { callCursorUnaryRpc } from "./cursor";