@playwo/opencode-cursor-oauth 0.0.0-dev.d7836f7ad39f → 0.0.0-dev.da5538092563

package/README.md

@@ -1,17 +1,24 @@
 # opencode-cursor-oauth
 
-Use Cursor models (Claude, GPT, Gemini, etc.) inside [OpenCode](https://opencode.ai).
+## Disclaimer
+
+> [!NOTE]
+> This project is a **fork** of [ephraimduncan/opencode-cursor](https://github.com/ephraimduncan/opencode-cursor). Upstream may differ in behavior, features, or maintenance; treat this repository as its own line of development.
 
 ## What it does
 
-- **OAuth login** to Cursor via browser
-- **Model discovery** — automatically fetches your available Cursor models
-- **Local proxy** — runs an OpenAI-compatible endpoint that translates to Cursor's gRPC protocol
-- **Auto-refresh** — handles token expiration automatically
+This is an [OpenCode](https://opencode.ai) plugin that lets you use **Cursor cloud models** (Claude, GPT, Gemini, and whatever your Cursor account exposes) from inside OpenCode.
+
+- **OAuth login** to Cursor in the browser
+- **Model discovery** — loads the models available to your Cursor account
+- **Local OpenAI-compatible proxy** — translates OpenCode’s requests to Cursor’s gRPC API
+- **Token refresh** — refreshes access tokens so sessions keep working
+
+There are **no extra runtime requirements** beyond what OpenCode already needs: you do not install Node, Python, or Docker separately for this plugin. Enable it in OpenCode’s config and complete login in the UI.
 
 ## Install
 
-Add to your `opencode.json`:
+Add the package to your OpenCode configuration (for example `opencode.json`):
 
 ```json
 {
@@ -19,13 +26,27 @@ Add to your `opencode.json`:
 }
 ```
 
-Then authenticate via the OpenCode UI (Settings → Providers → Cursor → Login).
+Install or update dependencies the way you normally do for OpenCode plugins (e.g. ensure the package is available to your OpenCode environment). You need **OpenCode 1.2+** and a **Cursor account** with API/model access.
+
+## Connect auth and use it
+
+1. Start OpenCode with the plugin enabled.
+2. Open **Settings → Providers → Cursor** (wording may vary slightly by OpenCode version).
+3. Choose **Login** (or equivalent) and complete **OAuth** in the browser when prompted.
+4. After login, pick a Cursor-backed model from the model list and use OpenCode as usual.
+
+If something fails, check that you are signed into the correct Cursor account and that your plan includes the models you expect.
+
+## Compatibiliy Notes
+
+Cursor is not a raw model endpoint like the others supported in Opencode. It brings its own system prompt tools and mechanics.
+This plugin does try its best to make mcps, skills etc installed in Opencode work in Cursor.
 
-## Requirements
+There are some issues with Cursors system prompt in this environment tho. Cursor adds various tools to the agent which opencode does not have, hence when the agent calls these they will be rejected which can sometimes lead to the agent no longer responding. Am still looking for a way to fix this, till then when the agent stops responding for a while interrupt it and tell it to continue again.
 
-- Cursor account with API access
-- OpenCode 1.2+
+## Stability and issues
 
-## License
+This integration can be **buggy** or break when Cursor or OpenCode change their APIs or UI.
 
-MIT
+> [!TIP]
+> If you hit problems, missing models, or confusing errors, please **[open an issue](https://github.com/PoolPirate/opencode-cursor/issues)** on this repository with steps to reproduce and logs or screenshots when possible.

package/dist/cursor/bidi-session.d.ts

@@ -1,5 +1,4 @@
 import { type CursorBaseRequestOptions } from "./headers";
-export declare function encodeBidiAppendRequest(dataHex: string, requestId: string, appendSeqno: number): Uint8Array;
 export interface CursorSession {
     write: (data: Uint8Array) => void;
     end: () => void;
@@ -8,6 +7,6 @@ export interface CursorSession {
     readonly alive: boolean;
 }
 export interface CreateCursorSessionOptions extends CursorBaseRequestOptions {
-    requestId: string;
+    initialRequestBytes: Uint8Array;
 }
 export declare function createCursorSession(options: CreateCursorSessionOptions): Promise<CursorSession>;

package/dist/cursor/bidi-session.js

@@ -1,149 +1,164 @@
-import { create, toBinary } from "@bufbuild/protobuf";
-import { BidiRequestIdSchema } from "../proto/agent_pb";
-import { CURSOR_API_URL } from "./config";
-import { concatBytes, encodeProtoMessageField, encodeProtoStringField, encodeProtoVarintField, frameConnectMessage, toFetchBody, } from "./connect-framing";
-import { buildCursorHeaders } from "./headers";
-import { errorDetails, logPluginError, logPluginWarn } from "../logger";
-export function encodeBidiAppendRequest(dataHex, requestId, appendSeqno) {
-    const requestIdBytes = toBinary(BidiRequestIdSchema, create(BidiRequestIdSchema, { requestId }));
-    return concatBytes([
-        encodeProtoStringField(1, dataHex),
-        encodeProtoMessageField(2, requestIdBytes),
-        encodeProtoVarintField(3, appendSeqno),
-    ]);
-}
+import { connect as connectHttp2, } from "node:http2";
+import { CURSOR_API_URL, CURSOR_CONNECT_PROTOCOL_VERSION } from "./config";
+import { frameConnectMessage } from "./connect-framing";
+import { buildCursorHeaderValues, } from "./headers";
+import { errorDetails, logPluginError } from "../logger";
+const CURSOR_BIDI_RUN_PATH = "/agent.v1.AgentService/Run";
 export async function createCursorSession(options) {
-    const response = await fetch(new URL("/agent.v1.AgentService/RunSSE", options.url ?? CURSOR_API_URL), {
-        method: "POST",
-        headers: buildCursorHeaders(options, "application/connect+proto", {
-            accept: "text/event-stream",
-            "connect-protocol-version": "1",
-        }),
-        body: toFetchBody(frameConnectMessage(toBinary(BidiRequestIdSchema, create(BidiRequestIdSchema, { requestId: options.requestId })))),
-    });
-    if (!response.ok || !response.body) {
-        const errorBody = await response.text().catch(() => "");
-        logPluginError("Cursor RunSSE request failed", {
-            requestId: options.requestId,
-            status: response.status,
-            responseBody: errorBody,
-        });
-        throw new Error(`RunSSE failed: ${response.status}${errorBody ? ` ${errorBody}` : ""}`);
+    if (options.initialRequestBytes.length === 0) {
+        throw new Error("Cursor sessions require an initial request message");
     }
-    const cbs = {
-        data: null,
-        close: null,
-    };
-    const abortController = new AbortController();
-    const reader = response.body.getReader();
-    let appendSeqno = 0;
-    let alive = true;
-    let closeCode = 0;
-    let writeChain = Promise.resolve();
-    const pendingChunks = [];
-    const finish = (code) => {
-        if (!alive)
-            return;
-        alive = false;
-        closeCode = code;
-        cbs.close?.(code);
-    };
-    const append = async (data) => {
-        const requestBody = encodeBidiAppendRequest(Buffer.from(data).toString("hex"), options.requestId, appendSeqno++);
-        const appendResponse = await fetch(new URL("/aiserver.v1.BidiService/BidiAppend", options.url ?? CURSOR_API_URL), {
-            method: "POST",
-            headers: buildCursorHeaders(options, "application/proto"),
-            body: toFetchBody(requestBody),
-            signal: abortController.signal,
-        });
-        if (!appendResponse.ok) {
-            const errorBody = await appendResponse.text().catch(() => "");
-            logPluginError("Cursor BidiAppend request failed", {
-                requestId: options.requestId,
-                appendSeqno: appendSeqno - 1,
-                status: appendResponse.status,
-                responseBody: errorBody,
-            });
-            throw new Error(`BidiAppend failed: ${appendResponse.status}${errorBody ? ` ${errorBody}` : ""}`);
-        }
-        await appendResponse.arrayBuffer().catch(() => undefined);
-    };
-    (async () => {
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    finish(0);
-                    break;
-                }
-                if (value && value.length > 0) {
-                    const chunk = Buffer.from(value);
-                    if (cbs.data) {
-                        cbs.data(chunk);
-                    }
-                    else {
-                        pendingChunks.push(chunk);
-                    }
-                }
+    const target = new URL(CURSOR_BIDI_RUN_PATH, options.url ?? CURSOR_API_URL);
+    const authority = `${target.protocol}//${target.host}`;
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+        const cbs = {
+            data: null,
+            close: null,
+        };
+        let session;
+        let stream;
+        let alive = true;
+        let closeCode = 0;
+        let opened = false;
+        let settled = false;
+        let statusCode = 0;
+        const pendingChunks = [];
+        const errorChunks = [];
+        const closeTransport = () => {
+            try {
+                stream?.close();
             }
-        }
-        catch (error) {
-            logPluginWarn("Cursor stream reader closed with error", {
-                requestId: options.requestId,
+            catch { }
+            try {
+                session?.close();
+            }
+            catch { }
+        };
+        const finish = (code) => {
+            if (!alive)
+                return;
+            alive = false;
+            closeCode = code;
+            cbs.close?.(code);
+            closeTransport();
+        };
+        const rejectOpen = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            alive = false;
+            closeTransport();
+            reject(error);
+        };
+        const resolveOpen = (sessionHandle) => {
+            if (settled)
+                return;
+            settled = true;
+            opened = true;
+            resolve(sessionHandle);
+        };
+        const handleTransportError = (message, error) => {
+            logPluginError(message, {
+                requestId,
+                url: target.toString(),
                 ...errorDetails(error),
             });
-            finish(alive ? 1 : closeCode);
-        }
-    })();
-    return {
-        get alive() {
-            return alive;
-        },
-        write(data) {
-            if (!alive)
+            if (!opened) {
+                rejectOpen(new Error(error instanceof Error ? error.message : String(error ?? message)));
                 return;
-            writeChain = writeChain
-                .then(() => append(data))
-                .catch((error) => {
-                logPluginError("Cursor stream append failed", {
-                    requestId: options.requestId,
-                    ...errorDetails(error),
-                });
+            }
+            finish(1);
+        };
+        const sessionHandle = {
+            get alive() {
+                return alive;
+            },
+            write(data) {
+                if (!alive || !stream)
+                    return;
                 try {
-                    abortController.abort();
+                    stream.write(frameConnectMessage(data));
                 }
-                catch { }
-                try {
-                    reader.cancel();
+                catch (error) {
+                    handleTransportError("Cursor HTTP/2 write failed", error);
+                }
+            },
+            end() {
+                finish(0);
+            },
+            onData(cb) {
+                cbs.data = cb;
+                while (pendingChunks.length > 0) {
+                    cb(pendingChunks.shift());
+                }
+            },
+            onClose(cb) {
+                if (!alive) {
+                    queueMicrotask(() => cb(closeCode));
                 }
-                catch { }
-                finish(1);
+                else {
+                    cbs.close = cb;
+                }
+            },
+        };
+        try {
+            session = connectHttp2(authority);
+            session.once("error", (error) => {
+                handleTransportError("Cursor HTTP/2 session failed", error);
             });
-        },
-        end() {
-            try {
-                abortController.abort();
-            }
-            catch { }
-            try {
-                reader.cancel();
-            }
-            catch { }
-            finish(0);
-        },
-        onData(cb) {
-            cbs.data = cb;
-            while (pendingChunks.length > 0) {
-                cb(pendingChunks.shift());
-            }
-        },
-        onClose(cb) {
-            if (!alive) {
-                queueMicrotask(() => cb(closeCode));
-            }
-            else {
-                cbs.close = cb;
-            }
-        },
-    };
+            const headers = {
+                ":method": "POST",
+                ":path": `${target.pathname}${target.search}`,
+                ...buildCursorHeaderValues(options, "application/connect+proto", {
+                    accept: "application/connect+proto",
+                    "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
+                }),
+            };
+            stream = session.request(headers);
+            stream.once("response", (responseHeaders) => {
+                const statusHeader = responseHeaders[":status"];
+                statusCode =
+                    typeof statusHeader === "number"
+                        ? statusHeader
+                        : Number(statusHeader ?? 0);
+                if (statusCode >= 200 && statusCode < 300) {
+                    resolveOpen(sessionHandle);
+                }
+            });
+            stream.on("data", (chunk) => {
+                const buffer = Buffer.from(chunk);
+                if (!opened && statusCode >= 400) {
+                    errorChunks.push(buffer);
+                    return;
+                }
+                if (cbs.data) {
+                    cbs.data(buffer);
+                }
+                else {
+                    pendingChunks.push(buffer);
+                }
+            });
+            stream.once("end", () => {
+                if (!opened) {
+                    const errorBody = Buffer.concat(errorChunks).toString("utf8").trim();
+                    logPluginError("Cursor HTTP/2 Run request failed", {
+                        requestId,
+                        status: statusCode,
+                        responseBody: errorBody,
+                    });
+                    rejectOpen(new Error(`Run failed: ${statusCode || 1}${errorBody ? ` ${errorBody}` : ""}`));
+                    return;
+                }
+                finish(statusCode >= 200 && statusCode < 300 ? 0 : statusCode || 1);
+            });
+            stream.once("error", (error) => {
+                handleTransportError("Cursor HTTP/2 stream failed", error);
+            });
+            stream.write(frameConnectMessage(options.initialRequestBytes));
+        }
+        catch (error) {
+            handleTransportError("Cursor HTTP/2 transport setup failed", error);
+        }
+    });
 }

package/dist/cursor/index.d.ts

@@ -1,5 +1,5 @@
 export { CURSOR_API_URL, CURSOR_CLIENT_VERSION, CURSOR_CONNECT_PROTOCOL_VERSION, CONNECT_END_STREAM_FLAG, } from "./config";
 export { concatBytes, decodeConnectUnaryBody, encodeProtoMessageField, encodeProtoStringField, encodeProtoVarintField, encodeVarint, frameConnectMessage, toFetchBody, } from "./connect-framing";
 export { buildCursorHeaders, buildCursorHeaderValues, type CursorBaseRequestOptions, } from "./headers";
-export { createCursorSession, encodeBidiAppendRequest, type CreateCursorSessionOptions, type CursorSession, } from "./bidi-session";
+export { createCursorSession, type CreateCursorSessionOptions, type CursorSession, } from "./bidi-session";
 export { callCursorUnaryRpc, type CursorUnaryRpcOptions } from "./unary-rpc";

package/dist/cursor/index.js

@@ -1,5 +1,5 @@
 export { CURSOR_API_URL, CURSOR_CLIENT_VERSION, CURSOR_CONNECT_PROTOCOL_VERSION, CONNECT_END_STREAM_FLAG, } from "./config";
 export { concatBytes, decodeConnectUnaryBody, encodeProtoMessageField, encodeProtoStringField, encodeProtoVarintField, encodeVarint, frameConnectMessage, toFetchBody, } from "./connect-framing";
 export { buildCursorHeaders, buildCursorHeaderValues, } from "./headers";
-export { createCursorSession, encodeBidiAppendRequest, } from "./bidi-session";
+export { createCursorSession, } from "./bidi-session";
 export { callCursorUnaryRpc } from "./unary-rpc";

package/dist/cursor/unary-rpc.d.ts

@@ -4,7 +4,6 @@ export interface CursorUnaryRpcOptions {
     requestBody: Uint8Array;
     url?: string;
     timeoutMs?: number;
-    transport?: "auto" | "fetch" | "http2";
 }
 export declare function callCursorUnaryRpc(options: CursorUnaryRpcOptions): Promise<{
     body: Uint8Array;

package/dist/cursor/unary-rpc.js

@@ -1,67 +1,10 @@
 import { connect as connectHttp2, } from "node:http2";
 import { CURSOR_API_URL, CURSOR_CONNECT_PROTOCOL_VERSION } from "./config";
-import { toFetchBody } from "./connect-framing";
-import { buildCursorHeaders, buildCursorHeaderValues } from "./headers";
+import { buildCursorHeaderValues } from "./headers";
 import { errorDetails, logPluginError } from "../logger";
 export async function callCursorUnaryRpc(options) {
     const target = new URL(options.rpcPath, options.url ?? CURSOR_API_URL);
-    const transport = options.transport ?? "auto";
-    if (transport === "http2" ||
-        (transport === "auto" && target.protocol === "https:")) {
-        const http2Result = await callCursorUnaryRpcOverHttp2(options, target);
-        if (transport === "http2" ||
-            http2Result.timedOut ||
-            http2Result.exitCode !== 1) {
-            return http2Result;
-        }
-    }
-    return callCursorUnaryRpcOverFetch(options, target);
-}
-async function callCursorUnaryRpcOverFetch(options, target) {
-    let timedOut = false;
-    const timeoutMs = options.timeoutMs ?? 5_000;
-    const controller = new AbortController();
-    const timeout = timeoutMs > 0
-        ? setTimeout(() => {
-            timedOut = true;
-            controller.abort();
-        }, timeoutMs)
-        : undefined;
-    try {
-        const response = await fetch(target, {
-            method: "POST",
-            headers: buildCursorHeaders(options, "application/proto", {
-                accept: "application/proto, application/json",
-                "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
-                "connect-timeout-ms": String(timeoutMs),
-            }),
-            body: toFetchBody(options.requestBody),
-            signal: controller.signal,
-        });
-        const body = new Uint8Array(await response.arrayBuffer());
-        return {
-            body,
-            exitCode: response.ok ? 0 : response.status,
-            timedOut,
-        };
-    }
-    catch {
-        logPluginError("Cursor unary fetch transport failed", {
-            rpcPath: options.rpcPath,
-            url: target.toString(),
-            timeoutMs,
-            timedOut,
-        });
-        return {
-            body: new Uint8Array(),
-            exitCode: timedOut ? 124 : 1,
-            timedOut,
-        };
-    }
-    finally {
-        if (timeout)
-            clearTimeout(timeout);
-    }
+    return callCursorUnaryRpcOverHttp2(options, target);
 }
 async function callCursorUnaryRpcOverHttp2(options, target) {
     const timeoutMs = options.timeoutMs ?? 5_000;

package/dist/logger.d.ts

@@ -2,5 +2,6 @@ import type { PluginInput } from "@opencode-ai/plugin";
 export declare function configurePluginLogger(input: PluginInput): void;
 export declare function errorDetails(error: unknown): Record<string, unknown>;
 export declare function logPluginWarn(message: string, extra?: Record<string, unknown>): void;
+export declare function logPluginInfo(message: string, extra?: Record<string, unknown>): void;
 export declare function logPluginError(message: string, extra?: Record<string, unknown>): void;
 export declare function flushPluginLogs(): Promise<void>;

package/dist/logger.js

@@ -27,6 +27,9 @@ export function errorDetails(error) {
 export function logPluginWarn(message, extra = {}) {
     logPlugin("warn", message, extra);
 }
+export function logPluginInfo(message, extra = {}) {
+    logPlugin("info", message, extra);
+}
 export function logPluginError(message, extra = {}) {
     logPlugin("error", message, extra);
 }

package/dist/openai/messages.d.ts

@@ -13,7 +13,6 @@ interface ParsedMessages {
     toolResults: ToolResultInfo[];
     pendingAssistantSummary: string;
     completedTurnsFingerprint: string;
-    assistantContinuation: boolean;
 }
 /** Normalize OpenAI message content to a plain string. */
 export declare function textContent(content: OpenAIMessage["content"]): string;

package/dist/openai/messages.js

@@ -64,7 +64,6 @@ export function parseMessages(messages) {
     let userText = "";
     let toolResults = [];
     let pendingAssistantSummary = "";
-    let assistantContinuation = false;
     let completedTurnStates = parsedTurns;
     const lastTurn = parsedTurns.at(-1);
     if (lastTurn) {
@@ -84,7 +83,6 @@ export function parseMessages(messages) {
             completedTurnStates = parsedTurns.slice(0, -1);
             userText = lastTurn.userText;
             pendingAssistantSummary = summarizeTurnSegments(lastTurn.segments);
-            assistantContinuation = true;
         }
     }
     const turns = completedTurnStates
@@ -100,7 +98,6 @@ export function parseMessages(messages) {
         toolResults,
         pendingAssistantSummary,
         completedTurnsFingerprint: buildCompletedTurnsFingerprint(systemPrompt, turns),
-        assistantContinuation,
     };
 }
 function splitTrailingToolResults(segments) {

package/dist/plugin/cursor-auth-plugin.js

@@ -110,7 +110,6 @@ export const CursorAuthPlugin = async (input) => {
         async "chat.headers"(incoming, output) {
             if (incoming.model.providerID !== CURSOR_PROVIDER_ID)
                 return;
-            output.headers["x-opencode-session-id"] = incoming.sessionID;
             output.headers["x-session-id"] = incoming.sessionID;
             if (incoming.agent) {
                 output.headers["x-opencode-agent"] = incoming.agent;

package/dist/proxy/bridge-close-controller.d.ts

@@ -0,0 +1,6 @@
+import type { CursorSession } from "../cursor/bidi-session";
+export declare function createBridgeCloseController(bridge: CursorSession): {
+    noteTurnEnded: () => void;
+    noteCheckpoint: () => void;
+    dispose: () => void;
+};

package/dist/proxy/bridge-close-controller.js

@@ -0,0 +1,37 @@
+import { scheduleBridgeEnd } from "./stream-dispatch";
+const TURN_END_GRACE_MS = 750;
+export function createBridgeCloseController(bridge) {
+    let turnEnded = false;
+    let checkpointSeen = false;
+    let closeTimer;
+    const clearCloseTimer = () => {
+        if (!closeTimer)
+            return;
+        clearTimeout(closeTimer);
+        closeTimer = undefined;
+    };
+    const closeBridge = () => {
+        clearCloseTimer();
+        scheduleBridgeEnd(bridge);
+    };
+    return {
+        noteTurnEnded() {
+            turnEnded = true;
+            if (checkpointSeen) {
+                closeBridge();
+                return;
+            }
+            clearCloseTimer();
+            closeTimer = setTimeout(closeBridge, TURN_END_GRACE_MS);
+        },
+        noteCheckpoint() {
+            checkpointSeen = true;
+            if (turnEnded) {
+                closeBridge();
+            }
+        },
+        dispose() {
+            clearCloseTimer();
+        },
+    };
+}

package/dist/proxy/bridge-non-streaming.js

@@ -5,6 +5,7 @@ import { updateStoredConversationAfterCompletion } from "./conversation-state";
 import { startBridge } from "./bridge-session";
 import { updateConversationCheckpoint, syncStoredBlobStore, } from "./state-sync";
 import { computeUsage, createConnectFrameParser, createThinkingTagFilter, parseConnectEndStream, processServerMessage, scheduleBridgeEnd, } from "./stream-dispatch";
+import { createBridgeCloseController } from "./bridge-close-controller";
 export async function handleNonStreamingResponse(payload, accessToken, modelId, convKey, metadata) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
@@ -33,19 +34,18 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
     let endStreamError = null;
     const pendingToolCalls = [];
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
+    const bridgeCloseController = createBridgeCloseController(bridge);
     const state = {
         toolCallIndex: 0,
         pendingExecs: [],
         outputTokens: 0,
         totalTokens: 0,
-        interactionToolArgsText: new Map(),
-        emittedToolCallIds: new Set(),
     };
     const tagFilter = createThinkingTagFilter();
     bridge.onData(createConnectFrameParser((messageBytes) => {
         try {
             const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-            processServerMessage(serverMessage, payload.blobStore, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+            processServerMessage(serverMessage, payload.blobStore, payload.cloudRule, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
                 if (isThinking)
                     return;
                 const { content } = tagFilter.process(text);
@@ -60,7 +60,10 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
                     },
                 });
                 scheduleBridgeEnd(bridge);
-            }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), () => scheduleBridgeEnd(bridge), (info) => {
+            }, (checkpointBytes) => {
+                updateConversationCheckpoint(convKey, checkpointBytes);
+                bridgeCloseController.noteCheckpoint();
+            }, () => bridgeCloseController.noteTurnEnded(), (info) => {
                 endStreamError = new Error(`Cursor returned unsupported ${info.category}: ${info.caseName}${info.detail ? ` (${info.detail})` : ""}`);
                 logPluginError("Closing non-streaming Cursor bridge after unsupported message", {
                     modelId,
@@ -97,6 +100,7 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
         scheduleBridgeEnd(bridge);
     }));
     bridge.onClose(() => {
+        bridgeCloseController.dispose();
         clearInterval(heartbeatTimer);
         syncStoredBlobStore(convKey, payload.blobStore);
         const flushed = tagFilter.flush();

package/dist/proxy/bridge-session.js

@@ -2,12 +2,10 @@ import { createCursorSession } from "../cursor/bidi-session";
 import { makeHeartbeatBytes } from "./stream-dispatch";
 const HEARTBEAT_INTERVAL_MS = 5_000;
 export async function startBridge(accessToken, requestBytes) {
-    const requestId = crypto.randomUUID();
     const bridge = await createCursorSession({
         accessToken,
-        requestId,
+        initialRequestBytes: requestBytes,
     });
-    bridge.write(requestBytes);
     const heartbeatTimer = setInterval(() => bridge.write(makeHeartbeatBytes()), HEARTBEAT_INTERVAL_MS);
     return { bridge, heartbeatTimer };
 }