@playwo/opencode-cursor-oauth 0.0.0-dev.b8e6dd72a8b6 → 0.0.9

package/README.md

@@ -44,7 +44,7 @@ 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.
+2. Model discovery — queries Cursor's gRPC API for all available models.
 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

package/dist/index.js

@@ -1,8 +1,7 @@
 import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
 import { getCursorModels } from "./models";
-import { startProxy, stopProxy } from "./proxy";
+import { startProxy } from "./proxy";
 const CURSOR_PROVIDER_ID = "cursor";
-let lastModelDiscoveryError = null;
 /**
  * OpenCode plugin that provides Cursor authentication and model access.
  * Register in opencode.json: { "plugin": ["opencode-cursor-oauth"] }
@@ -30,25 +29,7 @@ export const CursorAuthPlugin = async (input) => {
                     });
                     accessToken = refreshed.access;
                 }
-                let models;
-                try {
-                    models = await getCursorModels(accessToken);
-                    lastModelDiscoveryError = null;
-                }
-                catch (error) {
-                    const message = error instanceof Error
-                        ? error.message
-                        : "Cursor model discovery failed.";
-                    stopProxy();
-                    if (provider) {
-                        provider.models = {};
-                    }
-                    if (message !== lastModelDiscoveryError) {
-                        lastModelDiscoveryError = message;
-                        await showDiscoveryFailureToast(input, message);
-                    }
-                    return buildDisabledProviderConfig(message);
-                }
+                const models = await getCursorModels(accessToken);
                 const port = await startProxy(async () => {
                     const currentAuth = await getAuth();
                     if (currentAuth.type !== "oauth") {
@@ -164,37 +145,6 @@ function buildCursorProviderModels(models, port) {
         },
     ]));
 }
-async function showDiscoveryFailureToast(input, message) {
-    try {
-        await input.client.tui.showToast({
-            body: {
-                title: "Cursor plugin disabled",
-                message,
-                variant: "error",
-                duration: 8_000,
-            },
-        });
-    }
-    catch { }
-}
-function buildDisabledProviderConfig(message) {
-    return {
-        baseURL: "http://127.0.0.1/cursor-disabled/v1",
-        apiKey: "cursor-disabled",
-        async fetch() {
-            return new Response(JSON.stringify({
-                error: {
-                    message,
-                    type: "server_error",
-                    code: "cursor_model_discovery_failed",
-                },
-            }), {
-                status: 503,
-                headers: { "Content-Type": "application/json" },
-            });
-        },
-    };
-}
 // $/M token rates from cursor.com/docs/models-and-pricing
 const MODEL_COST_TABLE = {
     // Anthropic

package/dist/models.d.ts

@@ -5,9 +5,6 @@ export interface CursorModel {
     contextWindow: number;
     maxTokens: number;
 }
-export declare class CursorModelDiscoveryError extends Error {
-    constructor(message: string);
-}
 export declare function getCursorModels(apiKey: string): Promise<CursorModel[]>;
 /** @internal Test-only. */
 export declare function clearModelCache(): void;

package/dist/models.js

@@ -1,9 +1,13 @@
+/**
+ * Cursor model discovery via GetUsableModels.
+ * Uses the H2 bridge for transport. Falls back to a hardcoded list
+ * when discovery fails.
+ */
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
 import { z } from "zod";
 import { callCursorUnaryRpc } from "./proxy";
 import { GetUsableModelsRequestSchema, GetUsableModelsResponseSchema, } from "./proto/agent_pb";
 const GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
-const MODEL_DISCOVERY_TIMEOUT_MS = 5_000;
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const DEFAULT_MAX_TOKENS = 64_000;
 const CursorModelDetailsSchema = z.object({
@@ -18,12 +22,24 @@ const CursorModelDetailsSchema = z.object({
         .transform((aliases) => (aliases ?? []).filter((alias) => typeof alias === "string")),
     thinkingDetails: z.unknown().optional(),
 });
-export class CursorModelDiscoveryError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "CursorModelDiscoveryError";
-    }
-}
+const FALLBACK_MODELS = [
+    // Composer models
+    { id: "composer-1", name: "Composer 1", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
+    { id: "composer-1.5", name: "Composer 1.5", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
+    // Claude models
+    { id: "claude-4.6-opus-high", name: "Claude 4.6 Opus", reasoning: true, contextWindow: 200_000, maxTokens: 128_000 },
+    { id: "claude-4.6-sonnet-medium", name: "Claude 4.6 Sonnet", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
+    { id: "claude-4.5-sonnet", name: "Claude 4.5 Sonnet", reasoning: true, contextWindow: 200_000, maxTokens: 64_000 },
+    // GPT models
+    { id: "gpt-5.4-medium", name: "GPT-5.4", reasoning: true, contextWindow: 272_000, maxTokens: 128_000 },
+    { id: "gpt-5.2", name: "GPT-5.2", reasoning: true, contextWindow: 400_000, maxTokens: 128_000 },
+    { id: "gpt-5.2-codex", name: "GPT-5.2 Codex", reasoning: true, contextWindow: 400_000, maxTokens: 128_000 },
+    { id: "gpt-5.3-codex", name: "GPT-5.3 Codex", reasoning: true, contextWindow: 400_000, maxTokens: 128_000 },
+    { id: "gpt-5.3-codex-spark-preview", name: "GPT-5.3 Codex Spark", reasoning: true, contextWindow: 128_000, maxTokens: 128_000 },
+    // Other models
+    { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro", reasoning: true, contextWindow: 1_000_000, maxTokens: 64_000 },
+    { id: "grok-code-fast-1", name: "Grok Code Fast 1", reasoning: false, contextWindow: 128_000, maxTokens: 64_000 },
+];
 async function fetchCursorUsableModels(apiKey) {
     try {
         const requestPayload = create(GetUsableModelsRequestSchema, {});
@@ -32,31 +48,18 @@ async function fetchCursorUsableModels(apiKey) {
             accessToken: apiKey,
             rpcPath: GET_USABLE_MODELS_PATH,
             requestBody,
-            timeoutMs: MODEL_DISCOVERY_TIMEOUT_MS,
         });
-        if (response.timedOut) {
-            throw new CursorModelDiscoveryError(`Cursor model discovery timed out after ${MODEL_DISCOVERY_TIMEOUT_MS}ms.`);
-        }
-        if (response.exitCode !== 0) {
-            throw new CursorModelDiscoveryError(buildDiscoveryHttpError(response.exitCode, response.body));
-        }
-        if (response.body.length === 0) {
-            throw new CursorModelDiscoveryError("Cursor model discovery returned an empty response.");
+        if (response.timedOut || response.exitCode !== 0 || response.body.length === 0) {
+            return null;
         }
         const decoded = decodeGetUsableModelsResponse(response.body);
-        if (!decoded) {
-            throw new CursorModelDiscoveryError("Cursor model discovery returned an unreadable response.");
-        }
+        if (!decoded)
+            return null;
         const models = normalizeCursorModels(decoded.models);
-        if (models.length === 0) {
-            throw new CursorModelDiscoveryError("Cursor model discovery returned no usable models.");
-        }
-        return models;
+        return models.length > 0 ? models : null;
     }
-    catch (error) {
-        if (error instanceof CursorModelDiscoveryError)
-            throw error;
-        throw new CursorModelDiscoveryError("Cursor model discovery failed.");
+    catch {
+        return null;
     }
 }
 let cachedModels = null;
@@ -64,43 +67,13 @@ export async function getCursorModels(apiKey) {
     if (cachedModels)
         return cachedModels;
     const discovered = await fetchCursorUsableModels(apiKey);
-    cachedModels = discovered;
+    cachedModels = discovered && discovered.length > 0 ? discovered : FALLBACK_MODELS;
     return cachedModels;
 }
 /** @internal Test-only. */
 export function clearModelCache() {
     cachedModels = null;
 }
-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}.${protocolHint}`;
-    }
-    return `Cursor model discovery failed with HTTP ${exitCode}: ${detail}.${protocolHint}`;
-}
-function extractDiscoveryErrorDetail(body) {
-    if (body.length === 0)
-        return null;
-    const text = new TextDecoder().decode(body).trim();
-    if (!text)
-        return null;
-    try {
-        const parsed = JSON.parse(text);
-        const code = typeof parsed.code === "string" ? parsed.code : undefined;
-        const message = typeof parsed.message === "string" ? parsed.message : undefined;
-        if (message && code)
-            return `${message} (${code})`;
-        if (message)
-            return message;
-        if (code)
-            return code;
-    }
-    catch { }
-    return text.length > 200 ? `${text.slice(0, 197)}...` : text;
-}
 function decodeGetUsableModelsResponse(payload) {
     try {
         return fromBinary(GetUsableModelsResponseSchema, payload);

package/dist/proxy.d.ts

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

package/dist/proxy.js

@@ -16,10 +16,8 @@ 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";
 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;
 const SSE_HEADERS = {
     "Content-Type": "text/event-stream",
@@ -49,19 +47,18 @@ function frameConnectMessage(data, flags = 0) {
     return frame;
 }
 function buildCursorHeaders(options, contentType, extra = {}) {
-    const headers = new Headers(buildCursorHeaderValues(options, contentType, extra));
-    return headers;
-}
-function buildCursorHeaderValues(options, contentType, extra = {}) {
-    return {
+    const headers = new Headers({
         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(),
-        ...extra,
-    };
+    });
+    for (const [key, value] of Object.entries(extra)) {
+        headers.set(key, value);
+    }
+    return headers;
 }
 function encodeVarint(value) {
     if (!Number.isSafeInteger(value) || value < 0) {
@@ -239,17 +236,6 @@ 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();
@@ -260,13 +246,9 @@ async function callCursorUnaryRpcOverFetch(options, target) {
         }, timeoutMs)
         : undefined;
     try {
-        const response = await fetch(target, {
+        const response = await fetch(new URL(options.rpcPath, options.url ?? CURSOR_API_URL), {
             method: "POST",
-            headers: buildCursorHeaders(options, "application/proto", {
-                accept: "application/proto, application/json",
-                "connect-protocol-version": CURSOR_CONNECT_PROTOCOL_VERSION,
-                "connect-timeout-ms": String(timeoutMs),
-            }),
+            headers: buildCursorHeaders(options, "application/proto"),
             body: toFetchBody(options.requestBody),
             signal: controller.signal,
         });
@@ -289,96 +271,6 @@ async function callCursorUnaryRpcOverFetch(options, target) {
             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", () => {
-                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", () => {
-                finish({
-                    body: new Uint8Array(),
-                    exitCode: timedOut ? 124 : 1,
-                    timedOut,
-                });
-            });
-            stream.end(Buffer.from(options.requestBody));
-        }
-        catch {
-            finish({
-                body: new Uint8Array(),
-                exitCode: timedOut ? 124 : 1,
-                timedOut,
-            });
-        }
-    });
-}
 let proxyServer;
 let proxyPort;
 let proxyAccessTokenProvider;

package/package.json

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