@playwo/opencode-cursor-oauth 0.0.0-dev.0cb3e1517254

package/README.md

@@ -0,0 +1,31 @@
+# opencode-cursor-oauth
+
+Use Cursor models (Claude, GPT, Gemini, etc.) inside [OpenCode](https://opencode.ai).
+
+## What it does
+
+- **OAuth login** to Cursor via browser
+- **Model discovery** — automatically fetches your available Cursor models
+- **Local proxy** — runs an OpenAI-compatible endpoint that translates to Cursor's gRPC protocol
+- **Auto-refresh** — handles token expiration automatically
+
+## Install
+
+Add to your `opencode.json`:
+
+```json
+{
+  "plugin": ["@playwo/opencode-cursor-oauth"]
+}
+```
+
+Then authenticate via the OpenCode UI (Settings → Providers → Cursor → Login).
+
+## Requirements
+
+- Cursor account with API access
+- OpenCode 1.2+
+
+## License
+
+MIT

package/dist/auth.d.ts

@@ -0,0 +1,22 @@
+export interface CursorAuthParams {
+    verifier: string;
+    challenge: string;
+    uuid: string;
+    loginUrl: string;
+}
+export interface CursorCredentials {
+    access: string;
+    refresh: string;
+    expires: number;
+}
+export declare function generateCursorAuthParams(): Promise<CursorAuthParams>;
+export declare function pollCursorAuth(uuid: string, verifier: string): Promise<{
+    accessToken: string;
+    refreshToken: string;
+}>;
+export declare function refreshCursorToken(refreshToken: string): Promise<CursorCredentials>;
+/**
+ * Extract JWT expiry with 5-minute safety margin.
+ * Falls back to 1 hour from now if token can't be parsed.
+ */
+export declare function getTokenExpiry(token: string): number;

package/dist/auth.js

@@ -0,0 +1,117 @@
+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 ??
+    "https://api2.cursor.sh/auth/exchange_user_api_key";
+const POLL_MAX_ATTEMPTS = 150;
+const POLL_BASE_DELAY = 1000;
+const POLL_MAX_DELAY = 10_000;
+const POLL_BACKOFF_MULTIPLIER = 1.2;
+export async function generateCursorAuthParams() {
+    const { verifier, challenge } = await generatePKCE();
+    const uuid = crypto.randomUUID();
+    const params = new URLSearchParams({
+        challenge,
+        uuid,
+        mode: "login",
+        redirectTarget: "cli",
+    });
+    const loginUrl = `${CURSOR_LOGIN_URL}?${params.toString()}`;
+    return { verifier, challenge, uuid, loginUrl };
+}
+export async function pollCursorAuth(uuid, verifier) {
+    let delay = POLL_BASE_DELAY;
+    let consecutiveErrors = 0;
+    for (let attempt = 0; attempt < POLL_MAX_ATTEMPTS; attempt++) {
+        await Bun.sleep(delay);
+        try {
+            const response = await fetch(`${CURSOR_POLL_URL}?uuid=${uuid}&verifier=${verifier}`);
+            if (response.status === 404) {
+                consecutiveErrors = 0;
+                delay = Math.min(delay * POLL_BACKOFF_MULTIPLIER, POLL_MAX_DELAY);
+                continue;
+            }
+            if (response.ok) {
+                const data = (await response.json());
+                return {
+                    accessToken: data.accessToken,
+                    refreshToken: data.refreshToken,
+                };
+            }
+            throw new Error(`Poll failed: ${response.status}`);
+        }
+        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) {
+    const response = await fetch(CURSOR_REFRESH_URL, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${refreshToken}`,
+            "Content-Type": "application/json",
+        },
+        body: "{}",
+    });
+    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());
+    return {
+        access: data.accessToken,
+        refresh: data.refreshToken || refreshToken,
+        expires: getTokenExpiry(data.accessToken),
+    };
+}
+/**
+ * Extract JWT expiry with 5-minute safety margin.
+ * Falls back to 1 hour from now if token can't be parsed.
+ */
+export function getTokenExpiry(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3 || !parts[1]) {
+            return Date.now() + 3600 * 1000;
+        }
+        const decoded = JSON.parse(atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")));
+        if (decoded &&
+            typeof decoded === "object" &&
+            typeof decoded.exp === "number") {
+            return decoded.exp * 1000 - 5 * 60 * 1000;
+        }
+    }
+    catch {
+    }
+    return Date.now() + 3600 * 1000;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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;

package/dist/index.js

@@ -0,0 +1,306 @@
+import { generateCursorAuthParams, getTokenExpiry, pollCursorAuth, refreshCursorToken, } from "./auth";
+import { configurePluginLogger, errorDetails, logPluginError, logPluginWarn } from "./logger";
+import { getCursorModels } from "./models";
+import { startProxy, stopProxy, } 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"] }
+ */
+export const CursorAuthPlugin = async (input) => {
+    configurePluginLogger(input);
+    return {
+        auth: {
+            provider: CURSOR_PROVIDER_ID,
+            async loader(getAuth, provider) {
+                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 = {};
+                    }
+                    if (message !== lastModelDiscoveryError) {
+                        lastModelDiscoveryError = message;
+                        await showDiscoveryFailureToast(input, message);
+                    }
+                    return buildDisabledProviderConfig(message);
+                }
+            },
+            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),
+                                };
+                            },
+                        };
+                    },
+                },
+            ],
+        },
+        async "chat.headers"(incoming, output) {
+            if (incoming.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            output.headers["x-opencode-session-id"] = incoming.sessionID;
+            output.headers["x-session-id"] = incoming.sessionID;
+            if (incoming.agent) {
+                output.headers["x-opencode-agent"] = incoming.agent;
+            }
+        },
+    };
+};
+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: {},
+        },
+    ]));
+}
+async function showDiscoveryFailureToast(input, message) {
+    try {
+        await input.client.tui.showToast({
+            body: {
+                title: "Cursor plugin disabled",
+                message,
+                variant: "error",
+                duration: 8_000,
+            },
+        });
+    }
+    catch (error) {
+        logPluginWarn("Failed to display Cursor plugin toast", {
+            title: "Cursor plugin disabled",
+            message,
+            ...errorDetails(error),
+        });
+    }
+}
+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
+    "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;

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.d.ts

@@ -0,0 +1,13 @@
+export interface CursorModel {
+    id: string;
+    name: string;
+    reasoning: boolean;
+    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;