@playwo/opencode-cursor-oauth 0.0.0-dev.17eadae36ea6 → 0.0.0-dev.65683458d3f1

package/README.md

@@ -1,103 +1,31 @@
-# @playwo/opencode-cursor-oauth
+# opencode-cursor-oauth
 
-OpenCode plugin that connects to Cursor's API, giving you access to Cursor
-models inside OpenCode with full tool-calling support.
+Use Cursor models (Claude, GPT, Gemini, etc.) inside [OpenCode](https://opencode.ai).
 
-## Install in OpenCode
+## What it does
 
-Add this to `~/.config/opencode/opencode.json`:
+- **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
 
-```jsonc
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    "@playwo/opencode-cursor-oauth"
-  ],
-  "provider": {
-    "cursor": {
-      "name": "Cursor"
-    }
-  }
-}
-```
-
-The `cursor` provider stub is required because OpenCode drops providers that do
-not already exist in its bundled provider catalog.
-
-OpenCode installs npm plugins automatically at startup, so users do not need to
-clone this repository.
-
-## Authenticate
-
-```sh
-opencode auth login --provider cursor
-```
-
-This opens Cursor OAuth in the browser. Tokens are stored in
-`~/.local/share/opencode/auth.json` and refreshed automatically.
-
-## Use
-
-Start OpenCode and select any Cursor model. The plugin starts a local
-OpenAI-compatible proxy on demand and routes requests through Cursor's gRPC API.
-
-## How it works
-
-1. OAuth — browser-based login to Cursor via PKCE.
-2. Model discovery — queries Cursor's gRPC API for all available models; if discovery fails, the plugin disables the Cursor provider for that load and shows a visible error toast instead of crashing OpenCode.
-3. Local proxy — translates `POST /v1/chat/completions` into Cursor's
-   protobuf/Connect protocol.
-4. Native tool routing — rejects Cursor's built-in filesystem/shell tools and
-   exposes OpenCode's tool surface via Cursor MCP instead.
-
-Cursor agent streaming uses Cursor's `RunSSE` + `BidiAppend` transport, so the
-plugin runs entirely inside OpenCode without a Node sidecar.
+## Install
 
-## Architecture
+Add to your `opencode.json`:
 
+```json
+{
+  "plugin": ["@playwo/opencode-cursor-oauth"]
+}
 ```
-OpenCode  -->  /v1/chat/completions  -->  Bun.serve (proxy)
-                                              |
-                              RunSSE stream + BidiAppend writes
-                                              |
-                                Cursor Connect/SSE transport
-                                              |
-                                     api2.cursor.sh gRPC
-```
-
-### Tool call flow
-
-```
-1. Cursor model receives OpenAI tools via RequestContext (as MCP tool defs)
-2. Model tries native tools (readArgs, shellArgs, etc.)
-3. Proxy rejects each with typed error (ReadRejected, ShellRejected, etc.)
-4. Model falls back to MCP tool -> mcpArgs exec message
-5. Proxy emits OpenAI tool_calls SSE chunk, pauses the Cursor stream
-6. OpenCode executes tool, sends result in follow-up request
-7. Proxy resumes the Cursor stream with mcpResult and continues streaming
-```
-
-## Develop locally
-
-```sh
-bun install
-bun run build
-bun test/smoke.ts
-```
-
-## Publish
 
-GitHub Actions publishes this package with `.github/workflows/publish-npm.yml`.
+Then authenticate via the OpenCode UI (Settings → Providers → Cursor → Login).
 
-- branch pushes publish a `dev` build as `0.0.0-dev.<sha>`
-- versioned releases publish `latest` using the `package.json` version and upload the packed `.tgz` to the GitHub release
-
-Repository secrets required:
+## Requirements
 
-- `NPM_TOKEN` for npm publish access
+- Cursor account with API access
+- OpenCode 1.2+
 
-## Requirements
+## License
 
-- [OpenCode](https://opencode.ai)
-- [Bun](https://bun.sh)
-- Active [Cursor](https://cursor.com) subscription
+MIT

package/dist/auth.js

@@ -1,4 +1,5 @@
 import { generatePKCE } from "./pkce";
+import { errorDetails, logPluginError, logPluginWarn } from "./logger";
 const CURSOR_LOGIN_URL = "https://cursor.com/loginDeepControl";
 const CURSOR_POLL_URL = "https://api2.cursor.sh/auth/poll";
 const CURSOR_REFRESH_URL = process.env.CURSOR_REFRESH_URL ??
@@ -40,13 +41,32 @@ export async function pollCursorAuth(uuid, verifier) {
             }
             throw new Error(`Poll failed: ${response.status}`);
         }
-        catch {
+        catch (error) {
             consecutiveErrors++;
             if (consecutiveErrors >= 3) {
+                logPluginError("Cursor auth polling failed repeatedly", {
+                    stage: "oauth_poll",
+                    uuid,
+                    attempts: attempt + 1,
+                    consecutiveErrors,
+                    ...errorDetails(error),
+                });
                 throw new Error("Too many consecutive errors during Cursor auth polling");
             }
+            logPluginWarn("Cursor auth polling attempt failed", {
+                stage: "oauth_poll",
+                uuid,
+                attempt: attempt + 1,
+                consecutiveErrors,
+                ...errorDetails(error),
+            });
         }
     }
+    logPluginError("Cursor authentication polling timed out", {
+        stage: "oauth_poll",
+        uuid,
+        attempts: POLL_MAX_ATTEMPTS,
+    });
     throw new Error("Cursor authentication polling timeout");
 }
 export async function refreshCursorToken(refreshToken) {
@@ -60,6 +80,11 @@ export async function refreshCursorToken(refreshToken) {
     });
     if (!response.ok) {
         const error = await response.text();
+        logPluginError("Cursor token refresh failed", {
+            stage: "token_refresh",
+            status: response.status,
+            responseBody: error,
+        });
         throw new Error(`Cursor token refresh failed: ${error}`);
     }
     const data = (await response.json());

package/dist/index.js

@@ -1,6 +1,7 @@
 import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
+import { configurePluginLogger, errorDetails, logPluginError, logPluginWarn } from "./logger";
 import { getCursorModels } from "./models";
-import { startProxy, stopProxy } from "./proxy";
+import { OPENCODE_AGENT_HEADER, OPENCODE_MESSAGE_ID_HEADER, OPENCODE_SESSION_ID_HEADER, startProxy, stopProxy, } from "./proxy";
 const CURSOR_PROVIDER_ID = "cursor";
 let lastModelDiscoveryError = null;
 /**
@@ -8,37 +9,90 @@ let lastModelDiscoveryError = null;
  * Register in opencode.json: { "plugin": ["opencode-cursor-oauth"] }
  */
 export const CursorAuthPlugin = async (input) => {
+    configurePluginLogger(input);
     return {
         auth: {
             provider: CURSOR_PROVIDER_ID,
             async loader(getAuth, provider) {
-                const auth = await getAuth();
-                if (!auth || auth.type !== "oauth")
-                    return {};
-                // Ensure we have a valid access token, refreshing if expired
-                let accessToken = auth.access;
-                if (!accessToken || auth.expires < Date.now()) {
-                    const refreshed = await refreshCursorToken(auth.refresh);
-                    await input.client.auth.set({
-                        path: { id: CURSOR_PROVIDER_ID },
-                        body: {
-                            type: "oauth",
-                            refresh: refreshed.refresh,
-                            access: refreshed.access,
-                            expires: refreshed.expires,
-                        },
-                    });
-                    accessToken = refreshed.access;
-                }
-                let models;
                 try {
+                    const auth = await getAuth();
+                    if (!auth || auth.type !== "oauth")
+                        return {};
+                    // Ensure we have a valid access token, refreshing if expired
+                    let accessToken = auth.access;
+                    if (!accessToken || auth.expires < Date.now()) {
+                        const refreshed = await refreshCursorToken(auth.refresh);
+                        await input.client.auth.set({
+                            path: { id: CURSOR_PROVIDER_ID },
+                            body: {
+                                type: "oauth",
+                                refresh: refreshed.refresh,
+                                access: refreshed.access,
+                                expires: refreshed.expires,
+                            },
+                        });
+                        accessToken = refreshed.access;
+                    }
+                    let models;
                     models = await getCursorModels(accessToken);
                     lastModelDiscoveryError = null;
+                    const port = await startProxy(async () => {
+                        const currentAuth = await getAuth();
+                        if (currentAuth.type !== "oauth") {
+                            const authError = new Error("Cursor auth not configured");
+                            logPluginError("Cursor proxy access token lookup failed", {
+                                stage: "proxy_access_token",
+                                ...errorDetails(authError),
+                            });
+                            throw authError;
+                        }
+                        if (!currentAuth.access || currentAuth.expires < Date.now()) {
+                            const refreshed = await refreshCursorToken(currentAuth.refresh);
+                            await input.client.auth.set({
+                                path: { id: CURSOR_PROVIDER_ID },
+                                body: {
+                                    type: "oauth",
+                                    refresh: refreshed.refresh,
+                                    access: refreshed.access,
+                                    expires: refreshed.expires,
+                                },
+                            });
+                            return refreshed.access;
+                        }
+                        return currentAuth.access;
+                    }, models);
+                    if (provider) {
+                        provider.models = buildCursorProviderModels(models, port);
+                    }
+                    return {
+                        baseURL: `http://localhost:${port}/v1`,
+                        apiKey: "cursor-proxy",
+                        async fetch(requestInput, init) {
+                            if (init?.headers) {
+                                if (init.headers instanceof Headers) {
+                                    init.headers.delete("authorization");
+                                }
+                                else if (Array.isArray(init.headers)) {
+                                    init.headers = init.headers.filter(([key]) => key.toLowerCase() !== "authorization");
+                                }
+                                else {
+                                    delete init.headers["authorization"];
+                                    delete init.headers["Authorization"];
+                                }
+                            }
+                            return fetch(requestInput, init);
+                        },
+                    };
                 }
                 catch (error) {
                     const message = error instanceof Error
                         ? error.message
                         : "Cursor model discovery failed.";
+                    logPluginError("Cursor auth loader failed", {
+                        stage: "loader",
+                        providerID: CURSOR_PROVIDER_ID,
+                        ...errorDetails(error),
+                    });
                     stopProxy();
                     if (provider) {
                         provider.models = {};
@@ -49,48 +103,6 @@ export const CursorAuthPlugin = async (input) => {
                     }
                     return buildDisabledProviderConfig(message);
                 }
-                const port = await startProxy(async () => {
-                    const currentAuth = await getAuth();
-                    if (currentAuth.type !== "oauth") {
-                        throw new Error("Cursor auth not configured");
-                    }
-                    if (!currentAuth.access || currentAuth.expires < Date.now()) {
-                        const refreshed = await refreshCursorToken(currentAuth.refresh);
-                        await input.client.auth.set({
-                            path: { id: CURSOR_PROVIDER_ID },
-                            body: {
-                                type: "oauth",
-                                refresh: refreshed.refresh,
-                                access: refreshed.access,
-                                expires: refreshed.expires,
-                            },
-                        });
-                        return refreshed.access;
-                    }
-                    return currentAuth.access;
-                }, models);
-                if (provider) {
-                    provider.models = buildCursorProviderModels(models, port);
-                }
-                return {
-                    baseURL: `http://localhost:${port}/v1`,
-                    apiKey: "cursor-proxy",
-                    async fetch(requestInput, init) {
-                        if (init?.headers) {
-                            if (init.headers instanceof Headers) {
-                                init.headers.delete("authorization");
-                            }
-                            else if (Array.isArray(init.headers)) {
-                                init.headers = init.headers.filter(([key]) => key.toLowerCase() !== "authorization");
-                            }
-                            else {
-                                delete init.headers["authorization"];
-                                delete init.headers["Authorization"];
-                            }
-                        }
-                        return fetch(requestInput, init);
-                    },
-                };
             },
             methods: [
                 {
@@ -116,6 +128,13 @@ export const CursorAuthPlugin = async (input) => {
                 },
             ],
         },
+        async "chat.headers"(input, output) {
+            if (input.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            output.headers[OPENCODE_SESSION_ID_HEADER] = input.sessionID;
+            output.headers[OPENCODE_AGENT_HEADER] = input.agent;
+            output.headers[OPENCODE_MESSAGE_ID_HEADER] = input.message.id;
+        },
     };
 };
 function buildCursorProviderModels(models, port) {
@@ -175,7 +194,13 @@ async function showDiscoveryFailureToast(input, message) {
             },
         });
     }
-    catch { }
+    catch (error) {
+        logPluginWarn("Failed to display Cursor plugin toast", {
+            title: "Cursor plugin disabled",
+            message,
+            ...errorDetails(error),
+        });
+    }
 }
 function buildDisabledProviderConfig(message) {
     return {

package/dist/logger.d.ts

@@ -0,0 +1,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 logPluginError(message: string, extra?: Record<string, unknown>): void;
+export declare function flushPluginLogs(): Promise<void>;

package/dist/logger.js

@@ -0,0 +1,142 @@
+const PLUGIN_LOG_SERVICE = "opencode-cursor-oauth";
+const MAX_STRING_LENGTH = 1_500;
+const MAX_ARRAY_LENGTH = 20;
+const MAX_OBJECT_KEYS = 25;
+let currentLogger;
+let pendingLogWrites = Promise.resolve();
+export function configurePluginLogger(input) {
+    currentLogger = {
+        client: input.client,
+        directory: input.directory,
+    };
+}
+export function errorDetails(error) {
+    if (error instanceof Error) {
+        return {
+            errorName: error.name,
+            errorMessage: error.message,
+            errorStack: error.stack,
+            errorCause: serializeValue(error.cause, 1),
+        };
+    }
+    return {
+        errorType: typeof error,
+        errorValue: serializeValue(error, 1),
+    };
+}
+export function logPluginWarn(message, extra = {}) {
+    logPlugin("warn", message, extra);
+}
+export function logPluginError(message, extra = {}) {
+    logPlugin("error", message, extra);
+}
+export function flushPluginLogs() {
+    return pendingLogWrites;
+}
+function logPlugin(level, message, extra) {
+    const serializedExtra = serializeValue(extra, 0);
+    writeConsoleLog(level, message, serializedExtra);
+    if (!currentLogger?.client?.app?.log) {
+        return;
+    }
+    pendingLogWrites = pendingLogWrites
+        .catch(() => { })
+        .then(async () => {
+        try {
+            await currentLogger?.client.app.log({
+                query: { directory: currentLogger.directory },
+                body: {
+                    service: PLUGIN_LOG_SERVICE,
+                    level,
+                    message,
+                    extra: serializedExtra,
+                },
+            });
+        }
+        catch (logError) {
+            writeConsoleLog("warn", "Failed to forward plugin log to OpenCode", {
+                originalLevel: level,
+                originalMessage: message,
+                ...errorDetails(logError),
+            });
+        }
+    });
+}
+function writeConsoleLog(level, message, extra) {
+    const prefix = `[${PLUGIN_LOG_SERVICE}] ${message}`;
+    const suffix = Object.keys(extra).length > 0 ? ` ${JSON.stringify(extra)}` : "";
+    if (level === "error") {
+        console.error(`${prefix}${suffix}`);
+        return;
+    }
+    console.warn(`${prefix}${suffix}`);
+}
+function serializeValue(value, depth, seen = new WeakSet()) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "string")
+        return truncateString(value);
+    const valueType = typeof value;
+    if (valueType === "number" || valueType === "boolean")
+        return value;
+    if (valueType === "bigint")
+        return value.toString();
+    if (valueType === "symbol")
+        return String(value);
+    if (valueType === "function")
+        return `[function ${value.name || "anonymous"}]`;
+    if (value instanceof URL)
+        return value.toString();
+    if (value instanceof Headers)
+        return Object.fromEntries(value.entries());
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: truncateString(value.stack),
+            cause: serializeValue(value.cause, depth + 1, seen),
+        };
+    }
+    if (value instanceof Uint8Array) {
+        return serializeBinary(value);
+    }
+    if (Array.isArray(value)) {
+        if (depth >= 3)
+            return `[array(${value.length})]`;
+        return value.slice(0, MAX_ARRAY_LENGTH).map((entry) => serializeValue(entry, depth + 1, seen));
+    }
+    if (typeof value === "object") {
+        if (seen.has(value))
+            return "[circular]";
+        seen.add(value);
+        if (depth >= 3) {
+            return `[object ${value.constructor?.name || "Object"}]`;
+        }
+        const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
+        return Object.fromEntries(entries.map(([key, entry]) => [key, serializeValue(entry, depth + 1, seen)]));
+    }
+    return String(value);
+}
+function serializeBinary(value) {
+    const text = new TextDecoder().decode(value);
+    const printable = /^[\x09\x0a\x0d\x20-\x7e]*$/.test(text);
+    if (printable) {
+        return {
+            type: "uint8array",
+            length: value.length,
+            text: truncateString(text),
+        };
+    }
+    return {
+        type: "uint8array",
+        length: value.length,
+        base64: truncateString(Buffer.from(value).toString("base64")),
+    };
+}
+function truncateString(value) {
+    if (value === undefined)
+        return undefined;
+    if (value.length <= MAX_STRING_LENGTH)
+        return value;
+    return `${value.slice(0, MAX_STRING_LENGTH - 3)}...`;
+}

package/dist/models.js

@@ -1,5 +1,6 @@
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import { z } from "zod";
+import { errorDetails, logPluginError, logPluginWarn } from "./logger";
 import { callCursorUnaryRpc } from "./proxy";
 import { GetUsableModelsRequestSchema, GetUsableModelsResponseSchema, } from "./proto/agent_pb";
 const GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
@@ -35,16 +36,32 @@ async function fetchCursorUsableModels(apiKey) {
             timeoutMs: MODEL_DISCOVERY_TIMEOUT_MS,
         });
         if (response.timedOut) {
+            logPluginError("Cursor model discovery timed out", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+                timeoutMs: MODEL_DISCOVERY_TIMEOUT_MS,
+            });
             throw new CursorModelDiscoveryError(`Cursor model discovery timed out after ${MODEL_DISCOVERY_TIMEOUT_MS}ms.`);
         }
         if (response.exitCode !== 0) {
+            logPluginError("Cursor model discovery HTTP failure", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+                exitCode: response.exitCode,
+                responseBody: response.body,
+            });
             throw new CursorModelDiscoveryError(buildDiscoveryHttpError(response.exitCode, response.body));
         }
         if (response.body.length === 0) {
+            logPluginWarn("Cursor model discovery returned an empty response", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+            });
             throw new CursorModelDiscoveryError("Cursor model discovery returned an empty response.");
         }
         const decoded = decodeGetUsableModelsResponse(response.body);
         if (!decoded) {
+            logPluginError("Cursor model discovery returned an unreadable response", {
+                rpcPath: GET_USABLE_MODELS_PATH,
+                responseBody: response.body,
+            });
             throw new CursorModelDiscoveryError("Cursor model discovery returned an unreadable response.");
         }
         const models = normalizeCursorModels(decoded.models);
@@ -56,6 +73,10 @@ async function fetchCursorUsableModels(apiKey) {
     catch (error) {
         if (error instanceof CursorModelDiscoveryError)
             throw error;
+        logPluginError("Cursor model discovery crashed", {
+            rpcPath: GET_USABLE_MODELS_PATH,
+            ...errorDetails(error),
+        });
         throw new CursorModelDiscoveryError("Cursor model discovery failed.");
     }
 }
@@ -73,10 +94,13 @@ export function clearModelCache() {
 }
 function buildDiscoveryHttpError(exitCode, body) {
     const detail = extractDiscoveryErrorDetail(body);
+    const protocolHint = exitCode === 464
+        ? " Likely protocol mismatch: Cursor appears to expect an HTTP/2 Connect unary request."
+        : "";
     if (!detail) {
-        return `Cursor model discovery failed with HTTP ${exitCode}.`;
+        return `Cursor model discovery failed with HTTP ${exitCode}.${protocolHint}`;
     }
-    return `Cursor model discovery failed with HTTP ${exitCode}: ${detail}`;
+    return `Cursor model discovery failed with HTTP ${exitCode}: ${detail}.${protocolHint}`;
 }
 function extractDiscoveryErrorDetail(body) {
     if (body.length === 0)

package/dist/proxy.d.ts

@@ -1,9 +1,13 @@
+export declare const OPENCODE_SESSION_ID_HEADER = "x-opencode-session-id";
+export declare const OPENCODE_AGENT_HEADER = "x-opencode-agent";
+export declare const OPENCODE_MESSAGE_ID_HEADER = "x-opencode-message-id";
 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;

package/dist/proxy.js

@@ -16,14 +16,21 @@ import { create, fromBinary, fromJson, toBinary, toJson } from "@bufbuild/protob
 import { ValueSchema } from "@bufbuild/protobuf/wkt";
 import { AgentClientMessageSchema, AgentRunRequestSchema, AgentServerMessageSchema, BidiRequestIdSchema, ClientHeartbeatSchema, ConversationActionSchema, ConversationStateStructureSchema, ConversationStepSchema, AgentConversationTurnStructureSchema, ConversationTurnStructureSchema, AssistantMessageSchema, BackgroundShellSpawnResultSchema, DeleteResultSchema, DeleteRejectedSchema, DiagnosticsResultSchema, ExecClientMessageSchema, FetchErrorSchema, FetchResultSchema, GetBlobResultSchema, GrepErrorSchema, GrepResultSchema, KvClientMessageSchema, LsRejectedSchema, LsResultSchema, McpErrorSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolDefinitionSchema, McpToolResultContentItemSchema, ModelDetailsSchema, ReadRejectedSchema, ReadResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, SetBlobResultSchema, ShellRejectedSchema, ShellResultSchema, UserMessageActionSchema, UserMessageSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, } from "./proto/agent_pb";
 import { createHash } from "node:crypto";
+import { connect as connectHttp2 } from "node:http2";
+import { errorDetails, logPluginError, logPluginWarn } from "./logger";
 const CURSOR_API_URL = process.env.CURSOR_API_URL ?? "https://api2.cursor.sh";
 const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+const CURSOR_CONNECT_PROTOCOL_VERSION = "1";
 const CONNECT_END_STREAM_FLAG = 0b00000010;
+export const OPENCODE_SESSION_ID_HEADER = "x-opencode-session-id";
+export const OPENCODE_AGENT_HEADER = "x-opencode-agent";
+export const OPENCODE_MESSAGE_ID_HEADER = "x-opencode-message-id";
 const SSE_HEADERS = {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
     Connection: "keep-alive",
 };
+const EPHEMERAL_CURSOR_AGENTS = new Set(["title", "summary"]);
 // Active bridges keyed by a session token (derived from conversation state).
 // When tool_calls are returned, the bridge stays alive. The next request
 // with tool results looks up the bridge and sends mcpResult messages.
@@ -47,18 +54,19 @@ function frameConnectMessage(data, flags = 0) {
     return frame;
 }
 function buildCursorHeaders(options, contentType, extra = {}) {
-    const headers = new Headers({
+    const headers = new Headers(buildCursorHeaderValues(options, contentType, extra));
+    return headers;
+}
+function buildCursorHeaderValues(options, contentType, extra = {}) {
+    return {
         authorization: `Bearer ${options.accessToken}`,
         "content-type": contentType,
         "x-ghost-mode": "true",
         "x-cursor-client-version": CURSOR_CLIENT_VERSION,
         "x-cursor-client-type": "cli",
         "x-request-id": crypto.randomUUID(),
-    });
-    for (const [key, value] of Object.entries(extra)) {
-        headers.set(key, value);
-    }
-    return headers;
+        ...extra,
+    };
 }
 function encodeVarint(value) {
     if (!Number.isSafeInteger(value) || value < 0) {
@@ -130,6 +138,11 @@ async function createCursorSession(options) {
     });
     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}` : ""}`);
     }
     const cbs = {
@@ -160,6 +173,12 @@ async function createCursorSession(options) {
         });
         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);
@@ -183,7 +202,11 @@ async function createCursorSession(options) {
                 }
             }
         }
-        catch {
+        catch (error) {
+            logPluginWarn("Cursor stream reader closed with error", {
+                requestId: options.requestId,
+                ...errorDetails(error),
+            });
             finish(alive ? 1 : closeCode);
         }
     })();
@@ -196,7 +219,11 @@ async function createCursorSession(options) {
                 return;
             writeChain = writeChain
                 .then(() => append(data))
-                .catch(() => {
+                .catch((error) => {
+                logPluginError("Cursor stream append failed", {
+                    requestId: options.requestId,
+                    ...errorDetails(error),
+                });
                 try {
                     abortController.abort();
                 }
@@ -236,6 +263,17 @@ async function createCursorSession(options) {
     };
 }
 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();
@@ -246,9 +284,13 @@ export async function callCursorUnaryRpc(options) {
         }, timeoutMs)
         : undefined;
     try {
-        const response = await fetch(new URL(options.rpcPath, options.url ?? CURSOR_API_URL), {
+        const response = await fetch(target, {
             method: "POST",
-            headers: buildCursorHeaders(options, "application/proto"),
+            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,
         });
@@ -260,6 +302,12 @@ export async function callCursorUnaryRpc(options) {
         };
     }
     catch {
+        logPluginError("Cursor unary fetch transport failed", {
+            rpcPath: options.rpcPath,
+            url: target.toString(),
+            timeoutMs,
+            timedOut,
+        });
         return {
             body: new Uint8Array(),
             exitCode: timedOut ? 124 : 1,
@@ -271,6 +319,121 @@ export async function callCursorUnaryRpc(options) {
             clearTimeout(timeout);
     }
 }
+async function callCursorUnaryRpcOverHttp2(options, target) {
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const authority = `${target.protocol}//${target.host}`;
+    return new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let session;
+        let stream;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            try {
+                stream?.close();
+            }
+            catch { }
+            try {
+                session?.close();
+            }
+            catch { }
+            resolve(result);
+        };
+        const timeout = timeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: 124,
+                    timedOut: true,
+                });
+            }, timeoutMs)
+            : undefined;
+        try {
+            session = connectHttp2(authority);
+            session.once("error", (error) => {
+                logPluginError("Cursor unary HTTP/2 session failed", {
+                    rpcPath: options.rpcPath,
+                    url: target.toString(),
+                    timedOut,
+                    ...errorDetails(error),
+                });
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: timedOut ? 124 : 1,
+                    timedOut,
+                });
+            });
+            const headers = {
+                ":method": "POST",
+                ":path": `${target.pathname}${target.search}`,
+                ...buildCursorHeaderValues(options, "application/proto", {
+                    accept: "application/proto, application/json",
+                    "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
+                    "connect-timeout-ms": String(timeoutMs),
+                }),
+            };
+            stream = session.request(headers);
+            let statusCode = 0;
+            const chunks = [];
+            stream.once("response", (responseHeaders) => {
+                const statusHeader = responseHeaders[":status"];
+                statusCode = typeof statusHeader === "number"
+                    ? statusHeader
+                    : Number(statusHeader ?? 0);
+            });
+            stream.on("data", (chunk) => {
+                chunks.push(Buffer.from(chunk));
+            });
+            stream.once("end", () => {
+                const body = new Uint8Array(Buffer.concat(chunks));
+                finish({
+                    body,
+                    exitCode: statusCode >= 200 && statusCode < 300 ? 0 : (statusCode || 1),
+                    timedOut,
+                });
+            });
+            stream.once("error", (error) => {
+                logPluginError("Cursor unary HTTP/2 stream failed", {
+                    rpcPath: options.rpcPath,
+                    url: target.toString(),
+                    timedOut,
+                    ...errorDetails(error),
+                });
+                finish({
+                    body: new Uint8Array(),
+                    exitCode: timedOut ? 124 : 1,
+                    timedOut,
+                });
+            });
+            // Bun's node:http2 client currently breaks on end(Buffer.alloc(0)) against
+            // Cursor's HTTPS endpoint, but a header-only end() succeeds for empty unary bodies.
+            if (options.requestBody.length > 0) {
+                stream.end(Buffer.from(options.requestBody));
+            }
+            else {
+                stream.end();
+            }
+        }
+        catch (error) {
+            logPluginError("Cursor unary HTTP/2 setup failed", {
+                rpcPath: options.rpcPath,
+                url: target.toString(),
+                timedOut,
+                ...errorDetails(error),
+            });
+            finish({
+                body: new Uint8Array(),
+                exitCode: timedOut ? 124 : 1,
+                timedOut,
+            });
+        }
+    });
+}
 let proxyServer;
 let proxyPort;
 let proxyAccessTokenProvider;
@@ -312,10 +475,19 @@ export async function startProxy(getAccessToken, models = []) {
                         throw new Error("Cursor proxy access token provider not configured");
                     }
                     const accessToken = await proxyAccessTokenProvider();
-                    return handleChatCompletion(body, accessToken);
+                    return handleChatCompletion(body, accessToken, {
+                        sessionID: req.headers.get(OPENCODE_SESSION_ID_HEADER) ?? undefined,
+                        agent: req.headers.get(OPENCODE_AGENT_HEADER) ?? undefined,
+                        messageID: req.headers.get(OPENCODE_MESSAGE_ID_HEADER) ?? undefined,
+                    });
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
+                    logPluginError("Cursor proxy request failed", {
+                        path: url.pathname,
+                        method: req.method,
+                        ...errorDetails(err),
+                    });
                     return new Response(JSON.stringify({
                         error: { message, type: "server_error", code: "internal_error" },
                     }), { status: 500, headers: { "Content-Type": "application/json" } });
@@ -345,7 +517,7 @@ export function stopProxy() {
     activeBridges.clear();
     conversationStates.clear();
 }
-function handleChatCompletion(body, accessToken) {
+function handleChatCompletion(body, accessToken, requestScope = {}) {
     const { systemPrompt, userText, turns, toolResults } = parseMessages(body.messages);
     const modelId = body.model;
     const tools = body.tools ?? [];
@@ -359,8 +531,8 @@ function handleChatCompletion(body, accessToken) {
     }
     // bridgeKey: model-specific, for active tool-call bridges
     // convKey: model-independent, for conversation state that survives model switches
-    const bridgeKey = deriveBridgeKey(modelId, body.messages);
-    const convKey = deriveConversationKey(body.messages);
+    const bridgeKey = deriveBridgeKey(modelId, body.messages, requestScope);
+    const convKey = deriveConversationKey(body.messages, requestScope);
     const activeBridge = activeBridges.get(bridgeKey);
     if (activeBridge && toolResults.length > 0) {
         activeBridges.delete(bridgeKey);
@@ -382,7 +554,7 @@ function handleChatCompletion(body, accessToken) {
     let stored = conversationStates.get(convKey);
     if (!stored) {
         stored = {
-            conversationId: deterministicConversationId(convKey),
+            conversationId: crypto.randomUUID(),
             checkpoint: null,
             blobStore: new Map(),
             lastAccessMs: Date.now(),
@@ -744,6 +916,12 @@ function handleKvMessage(kvMsg, blobStore, sendFrame) {
         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") {
@@ -909,16 +1087,25 @@ function sendExecResult(execMsg, messageCase, value, sendFrame) {
     sendFrame(toBinary(AgentClientMessageSchema, clientMessage));
 }
 /** Derive a key for active bridge lookup (tool-call continuations). Model-specific. */
-function deriveBridgeKey(modelId, messages) {
+function deriveBridgeKey(modelId, messages, requestScope) {
     const firstUserMsg = messages.find((m) => m.role === "user");
     const firstUserText = firstUserMsg ? textContent(firstUserMsg.content) : "";
     return createHash("sha256")
-        .update(`bridge:${modelId}:${firstUserText.slice(0, 200)}`)
+        .update(`bridge:${requestScope.sessionID ?? ""}:${requestScope.agent ?? ""}:${modelId}:${firstUserText.slice(0, 200)}`)
         .digest("hex")
         .slice(0, 16);
 }
 /** Derive a key for conversation state. Model-independent so context survives model switches. */
-function deriveConversationKey(messages) {
+function deriveConversationKey(messages, requestScope) {
+    if (requestScope.sessionID) {
+        const scope = shouldIsolateConversation(requestScope)
+            ? `${requestScope.sessionID}:${requestScope.agent ?? ""}:${requestScope.messageID ?? crypto.randomUUID()}`
+            : `${requestScope.sessionID}:${requestScope.agent ?? "default"}`;
+        return createHash("sha256")
+            .update(`conv:${scope}`)
+            .digest("hex")
+            .slice(0, 16);
+    }
     const firstUserMsg = messages.find((m) => m.role === "user");
     const firstUserText = firstUserMsg ? textContent(firstUserMsg.content) : "";
     return createHash("sha256")
@@ -926,21 +1113,10 @@ function deriveConversationKey(messages) {
         .digest("hex")
         .slice(0, 16);
 }
-/** Deterministic UUID derived from convKey so Cursor's server-side conversation
- *  persists across proxy restarts. Formats 16 bytes of SHA-256 as a v4-shaped UUID. */
-function deterministicConversationId(convKey) {
-    const hex = createHash("sha256")
-        .update(`cursor-conv-id:${convKey}`)
-        .digest("hex")
-        .slice(0, 32);
-    // Format as UUID: xxxxxxxx-xxxx-4xxx-Nxxx-xxxxxxxxxxxx
-    return [
-        hex.slice(0, 8),
-        hex.slice(8, 12),
-        `4${hex.slice(13, 16)}`,
-        `${(0x8 | (parseInt(hex[16], 16) & 0x3)).toString(16)}${hex.slice(17, 20)}`,
-        hex.slice(20, 32),
-    ].join("-");
+function shouldIsolateConversation(requestScope) {
+    return Boolean(requestScope.agent
+        && EPHEMERAL_CURSOR_AGENTS.has(requestScope.agent)
+        && requestScope.messageID);
 }
 /** Create an SSE streaming Response that reads from a live bridge. */
 function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools, modelId, bridgeKey, convKey) {
@@ -992,6 +1168,7 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
             };
             const tagFilter = createThinkingTagFilter();
             let mcpExecReceived = false;
+            let endStreamError = null;
             const processChunk = createConnectFrameParser((messageBytes) => {
                 try {
                     const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
@@ -1051,9 +1228,14 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                     // Skip unparseable messages
                 }
             }, (endStreamBytes) => {
-                const endError = parseConnectEndStream(endStreamBytes);
-                if (endError) {
-                    sendSSE(makeChunk({ content: `\n[Error: ${endError.message}]` }));
+                endStreamError = parseConnectEndStream(endStreamBytes);
+                if (endStreamError) {
+                    logPluginError("Cursor stream returned Connect end-stream error", {
+                        modelId,
+                        bridgeKey,
+                        convKey,
+                        ...errorDetails(endStreamError),
+                    });
                 }
             });
             bridge.onData(processChunk);
@@ -1065,6 +1247,14 @@ function createBridgeStreamResponse(bridge, heartbeatTimer, blobStore, mcpTools,
                         stored.blobStore.set(k, v);
                     stored.lastAccessMs = Date.now();
                 }
+                if (endStreamError) {
+                    activeBridges.delete(bridgeKey);
+                    if (!closed) {
+                        closed = true;
+                        controller.error(endStreamError);
+                    }
+                    return;
+                }
                 if (!mcpExecReceived) {
                     const flushed = tagFilter.flush();
                     if (flushed.reasoning)
@@ -1154,7 +1344,7 @@ function handleToolResultResume(active, toolResults, modelId, bridgeKey, convKey
 async function handleNonStreamingResponse(payload, accessToken, modelId, convKey) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
-    const { text, usage } = await collectFullResponse(payload, accessToken, convKey);
+    const { text, usage } = await collectFullResponse(payload, accessToken, modelId, convKey);
     return new Response(JSON.stringify({
         id: completionId,
         object: "chat.completion",
@@ -1170,9 +1360,10 @@ async function handleNonStreamingResponse(payload, accessToken, modelId, convKey
         usage,
     }), { headers: { "Content-Type": "application/json" } });
 }
-async function collectFullResponse(payload, accessToken, convKey) {
-    const { promise, resolve } = Promise.withResolvers();
+async function collectFullResponse(payload, accessToken, modelId, convKey) {
+    const { promise, resolve, reject } = Promise.withResolvers();
     let fullText = "";
+    let endStreamError = null;
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
     const state = {
         toolCallIndex: 0,
@@ -1200,7 +1391,16 @@ async function collectFullResponse(payload, accessToken, convKey) {
         catch {
             // Skip
         }
-    }, () => { }));
+    }, (endStreamBytes) => {
+        endStreamError = parseConnectEndStream(endStreamBytes);
+        if (endStreamError) {
+            logPluginError("Cursor non-streaming response returned Connect end-stream error", {
+                modelId,
+                convKey,
+                ...errorDetails(endStreamError),
+            });
+        }
+    }));
     bridge.onClose(() => {
         clearInterval(heartbeatTimer);
         const stored = conversationStates.get(convKey);
@@ -1211,6 +1411,10 @@ async function collectFullResponse(payload, accessToken, convKey) {
         }
         const flushed = tagFilter.flush();
         fullText += flushed.content;
+        if (endStreamError) {
+            reject(endStreamError);
+            return;
+        }
         const usage = computeUsage(state);
         resolve({
             text: fullText,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwo/opencode-cursor-oauth",
-  "version": "0.0.0-dev.17eadae36ea6",
+  "version": "0.0.0-dev.65683458d3f1",
   "description": "OpenCode plugin that connects Cursor's API to OpenCode via OAuth, model discovery, and a local OpenAI-compatible proxy.",
   "license": "MIT",
   "type": "module",