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

package/dist/index.d.ts

@@ -1,14 +1,2 @@
-/**
- * OpenCode Cursor Auth Plugin
- *
- * Enables using Cursor models (Claude, GPT, etc.) inside OpenCode via:
- * 1. Browser-based OAuth login to Cursor
- * 2. Local proxy translating OpenAI format → Cursor gRPC protocol
- */
-import type { Plugin } from "@opencode-ai/plugin";
-/**
- * OpenCode plugin that provides Cursor authentication and model access.
- * Register in opencode.json: { "plugin": ["opencode-cursor-oauth"] }
- */
-export declare const CursorAuthPlugin: Plugin;
-export default CursorAuthPlugin;
+export { CursorAuthPlugin } from "./plugin/cursor-auth-plugin";
+export { CursorAuthPlugin as default } from "./plugin/cursor-auth-plugin";

package/dist/index.js

@@ -1,229 +1,2 @@
-import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
-import { getCursorModels } from "./models";
-import { startProxy } from "./proxy";
-const CURSOR_PROVIDER_ID = "cursor";
-/**
- * OpenCode plugin that provides Cursor authentication and model access.
- * Register in opencode.json: { "plugin": ["opencode-cursor-oauth"] }
- */
-export const CursorAuthPlugin = async (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;
-                }
-                const models = await getCursorModels(accessToken);
-                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: [
-                {
-                    type: "oauth",
-                    label: "Login with Cursor",
-                    async authorize() {
-                        const { verifier, uuid, loginUrl } = await generateCursorAuthParams();
-                        return {
-                            url: loginUrl,
-                            instructions: "Complete login in your browser. This window will close automatically.",
-                            method: "auto",
-                            async callback() {
-                                const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier);
-                                return {
-                                    type: "success",
-                                    refresh: refreshToken,
-                                    access: accessToken,
-                                    expires: getTokenExpiry(accessToken),
-                                };
-                            },
-                        };
-                    },
-                },
-            ],
-        },
-    };
-};
-function buildCursorProviderModels(models, port) {
-    return Object.fromEntries(models.map((model) => [
-        model.id,
-        {
-            id: model.id,
-            providerID: CURSOR_PROVIDER_ID,
-            api: {
-                id: model.id,
-                url: `http://localhost:${port}/v1`,
-                npm: "@ai-sdk/openai-compatible",
-            },
-            name: model.name,
-            capabilities: {
-                temperature: true,
-                reasoning: model.reasoning,
-                attachment: false,
-                toolcall: true,
-                input: {
-                    text: true,
-                    audio: false,
-                    image: false,
-                    video: false,
-                    pdf: false,
-                },
-                output: {
-                    text: true,
-                    audio: false,
-                    image: false,
-                    video: false,
-                    pdf: false,
-                },
-                interleaved: false,
-            },
-            cost: estimateModelCost(model.id),
-            limit: {
-                context: model.contextWindow,
-                output: model.maxTokens,
-            },
-            status: "active",
-            options: {},
-            headers: {},
-            release_date: "",
-            variants: {},
-        },
-    ]));
-}
-// $/M token rates from cursor.com/docs/models-and-pricing
-const MODEL_COST_TABLE = {
-    // Anthropic
-    "claude-4-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    "claude-4-sonnet-1m": { input: 6, output: 22.5, cache: { read: 0.6, write: 7.5 } },
-    "claude-4.5-haiku": { input: 1, output: 5, cache: { read: 0.1, write: 1.25 } },
-    "claude-4.5-opus": { input: 5, output: 25, cache: { read: 0.5, write: 6.25 } },
-    "claude-4.5-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    "claude-4.6-opus": { input: 5, output: 25, cache: { read: 0.5, write: 6.25 } },
-    "claude-4.6-opus-fast": { input: 30, output: 150, cache: { read: 3, write: 37.5 } },
-    "claude-4.6-sonnet": { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-    // Cursor
-    "composer-1": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "composer-1.5": { input: 3.5, output: 17.5, cache: { read: 0.35, write: 0 } },
-    "composer-2": { input: 0.5, output: 2.5, cache: { read: 0.2, write: 0 } },
-    "composer-2-fast": { input: 1.5, output: 7.5, cache: { read: 0.2, write: 0 } },
-    // Google
-    "gemini-2.5-flash": { input: 0.3, output: 2.5, cache: { read: 0.03, write: 0 } },
-    "gemini-3-flash": { input: 0.5, output: 3, cache: { read: 0.05, write: 0 } },
-    "gemini-3-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    "gemini-3-pro-image": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    "gemini-3.1-pro": { input: 2, output: 12, cache: { read: 0.2, write: 0 } },
-    // OpenAI
-    "gpt-5": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5-fast": { input: 2.5, output: 20, cache: { read: 0.25, write: 0 } },
-    "gpt-5-mini": { input: 0.25, output: 2, cache: { read: 0.025, write: 0 } },
-    "gpt-5-codex": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex-max": { input: 1.25, output: 10, cache: { read: 0.125, write: 0 } },
-    "gpt-5.1-codex-mini": { input: 0.25, output: 2, cache: { read: 0.025, write: 0 } },
-    "gpt-5.2": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.2-codex": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.3-codex": { input: 1.75, output: 14, cache: { read: 0.175, write: 0 } },
-    "gpt-5.4": { input: 2.5, output: 15, cache: { read: 0.25, write: 0 } },
-    "gpt-5.4-mini": { input: 0.75, output: 4.5, cache: { read: 0.075, write: 0 } },
-    "gpt-5.4-nano": { input: 0.2, output: 1.25, cache: { read: 0.02, write: 0 } },
-    // xAI
-    "grok-4.20": { input: 2, output: 6, cache: { read: 0.2, write: 0 } },
-    // Moonshot
-    "kimi-k2.5": { input: 0.6, output: 3, cache: { read: 0.1, write: 0 } },
-};
-// Most-specific first
-const MODEL_COST_PATTERNS = [
-    { match: (id) => /claude.*opus.*fast/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-opus-fast"] },
-    { match: (id) => /claude.*opus/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-opus"] },
-    { match: (id) => /claude.*haiku/i.test(id), cost: MODEL_COST_TABLE["claude-4.5-haiku"] },
-    { match: (id) => /claude.*sonnet/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-sonnet"] },
-    { match: (id) => /claude/i.test(id), cost: MODEL_COST_TABLE["claude-4.6-sonnet"] },
-    { match: (id) => /composer-?2/i.test(id), cost: MODEL_COST_TABLE["composer-2"] },
-    { match: (id) => /composer-?1\.5/i.test(id), cost: MODEL_COST_TABLE["composer-1.5"] },
-    { match: (id) => /composer/i.test(id), cost: MODEL_COST_TABLE["composer-1"] },
-    { match: (id) => /gpt-5\.4.*nano/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4-nano"] },
-    { match: (id) => /gpt-5\.4.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4-mini"] },
-    { match: (id) => /gpt-5\.4/i.test(id), cost: MODEL_COST_TABLE["gpt-5.4"] },
-    { match: (id) => /gpt-5\.3/i.test(id), cost: MODEL_COST_TABLE["gpt-5.3-codex"] },
-    { match: (id) => /gpt-5\.2/i.test(id), cost: MODEL_COST_TABLE["gpt-5.2"] },
-    { match: (id) => /gpt-5\.1.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5.1-codex-mini"] },
-    { match: (id) => /gpt-5\.1/i.test(id), cost: MODEL_COST_TABLE["gpt-5.1-codex"] },
-    { match: (id) => /gpt-5.*mini/i.test(id), cost: MODEL_COST_TABLE["gpt-5-mini"] },
-    { match: (id) => /gpt-5.*fast/i.test(id), cost: MODEL_COST_TABLE["gpt-5-fast"] },
-    { match: (id) => /gpt-5/i.test(id), cost: MODEL_COST_TABLE["gpt-5"] },
-    { match: (id) => /gemini.*3\.1/i.test(id), cost: MODEL_COST_TABLE["gemini-3.1-pro"] },
-    { match: (id) => /gemini.*3.*flash/i.test(id), cost: MODEL_COST_TABLE["gemini-3-flash"] },
-    { match: (id) => /gemini.*3/i.test(id), cost: MODEL_COST_TABLE["gemini-3-pro"] },
-    { match: (id) => /gemini.*flash/i.test(id), cost: MODEL_COST_TABLE["gemini-2.5-flash"] },
-    { match: (id) => /gemini/i.test(id), cost: MODEL_COST_TABLE["gemini-3.1-pro"] },
-    { match: (id) => /grok/i.test(id), cost: MODEL_COST_TABLE["grok-4.20"] },
-    { match: (id) => /kimi/i.test(id), cost: MODEL_COST_TABLE["kimi-k2.5"] },
-];
-const DEFAULT_COST = { input: 3, output: 15, cache: { read: 0.3, write: 0 } };
-function estimateModelCost(modelId) {
-    const normalized = modelId.toLowerCase();
-    const exact = MODEL_COST_TABLE[normalized];
-    if (exact)
-        return exact;
-    const stripped = normalized.replace(/-(high|medium|low|preview|thinking|spark-preview)$/g, "");
-    const strippedMatch = MODEL_COST_TABLE[stripped];
-    if (strippedMatch)
-        return strippedMatch;
-    return MODEL_COST_PATTERNS.find((p) => p.match(normalized))?.cost ?? DEFAULT_COST;
-}
-export default CursorAuthPlugin;
+export { CursorAuthPlugin } from "./plugin/cursor-auth-plugin";
+export { CursorAuthPlugin as default } from "./plugin/cursor-auth-plugin";

package/dist/logger.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,150 @@
+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 logPluginInfo(message, extra = {}) {
+    logPlugin("info", 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.d.ts

@@ -5,6 +5,9 @@ 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,13 +1,10 @@
-/**
- * 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 { callCursorUnaryRpc, decodeConnectUnaryBody } from "./cursor";
+import { errorDetails, logPluginError, logPluginWarn } from "./logger";
 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({
@@ -22,24 +19,12 @@ const CursorModelDetailsSchema = z.object({
         .transform((aliases) => (aliases ?? []).filter((alias) => typeof alias === "string")),
     thinkingDetails: z.unknown().optional(),
 });
-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 },
-];
+export class CursorModelDiscoveryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CursorModelDiscoveryError";
+    }
+}
 async function fetchCursorUsableModels(apiKey) {
     try {
         const requestPayload = create(GetUsableModelsRequestSchema, {});
@@ -48,18 +33,51 @@ async function fetchCursorUsableModels(apiKey) {
             accessToken: apiKey,
             rpcPath: GET_USABLE_MODELS_PATH,
             requestBody,
+            timeoutMs: MODEL_DISCOVERY_TIMEOUT_MS,
         });
-        if (response.timedOut || response.exitCode !== 0 || response.body.length === 0) {
-            return null;
+        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)
-            return null;
+        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);
-        return models.length > 0 ? models : null;
+        if (models.length === 0) {
+            throw new CursorModelDiscoveryError("Cursor model discovery returned no usable models.");
+        }
+        return models;
     }
-    catch {
-        return null;
+    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.");
     }
 }
 let cachedModels = null;
@@ -67,13 +85,43 @@ export async function getCursorModels(apiKey) {
     if (cachedModels)
         return cachedModels;
     const discovered = await fetchCursorUsableModels(apiKey);
-    cachedModels = discovered && discovered.length > 0 ? discovered : FALLBACK_MODELS;
+    cachedModels = discovered;
     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);
@@ -90,28 +138,6 @@ function decodeGetUsableModelsResponse(payload) {
         }
     }
 }
-function decodeConnectUnaryBody(payload) {
-    if (payload.length < 5)
-        return null;
-    let offset = 0;
-    while (offset + 5 <= payload.length) {
-        const flags = payload[offset];
-        const view = new DataView(payload.buffer, payload.byteOffset + offset, payload.byteLength - offset);
-        const messageLength = view.getUint32(1, false);
-        const frameEnd = offset + 5 + messageLength;
-        if (frameEnd > payload.length)
-            return null;
-        // Compression flag
-        if ((flags & 0b0000_0001) !== 0)
-            return null;
-        // End-of-stream flag — skip trailer frames
-        if ((flags & 0b0000_0010) === 0) {
-            return payload.subarray(offset + 5, frameEnd);
-        }
-        offset = frameEnd;
-    }
-    return null;
-}
 function normalizeCursorModels(models) {
     if (models.length === 0)
         return [];

package/dist/openai/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./messages";
+export * from "./tools";
+export * from "./types";

package/dist/openai/index.js

@@ -0,0 +1,3 @@
+export * from "./messages";
+export * from "./tools";
+export * from "./types";

package/dist/openai/messages.d.ts

@@ -0,0 +1,39 @@
+import type { ChatCompletionRequest, OpenAIMessage, OpenAIToolCall } from "./types";
+export interface ToolResultInfo {
+    toolCallId: string;
+    content: string;
+}
+interface ParsedMessages {
+    systemPrompt: string;
+    userText: string;
+    turns: Array<{
+        userText: string;
+        assistantText: string;
+    }>;
+    toolResults: ToolResultInfo[];
+    pendingAssistantSummary: string;
+    completedTurnsFingerprint: string;
+}
+/** Normalize OpenAI message content to a plain string. */
+export declare function textContent(content: OpenAIMessage["content"]): string;
+export declare function parseMessages(messages: OpenAIMessage[]): ParsedMessages;
+export declare function formatToolCallSummary(call: OpenAIToolCall): string;
+export declare function formatToolResultSummary(result: ToolResultInfo): string;
+export declare function buildCompletedTurnsFingerprint(systemPrompt: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>): string;
+export declare function buildToolResumePrompt(userText: string, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function buildInitialHandoffPrompt(userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function buildTitleSourceText(userText: string, turns: Array<{
+    userText: string;
+    assistantText: string;
+}>, pendingAssistantSummary: string, toolResults: ToolResultInfo[]): string;
+export declare function detectTitleRequest(body: ChatCompletionRequest): {
+    matched: boolean;
+    reason: string;
+};
+export {};