cursor-opencode-provider 0.1.1 → 0.1.3

package/README.md

@@ -6,6 +6,12 @@ This project is a custom **AI SDK provider** (`LanguageModelV3`) plus an **OpenC
 
 > **Status:** Usable end-to-end in OpenCode (auth, models, streaming, tools). See [Known limitations](#known-limitations).
 
+## Demo
+
+OpenCode driving a Cursor-routed Grok model through this provider:
+
+![OpenCode running a Grok model via cursor-opencode-provider](https://raw.githubusercontent.com/oakimov/cursor-opencode-provider/main/assets/opencode-grok.png)
+
 ## Features
 
 - **OpenCode integration** — registers a `cursor` provider with auth hooks and cached model list
@@ -41,7 +47,7 @@ Add the package name to OpenCode config. OpenCode installs npm plugins with Bun
 }
 ```
 
-Pin a version if you want: `"cursor-opencode-provider@0.1.1"`.
+Pin a version if you want: `"cursor-opencode-provider@0.1.3"`.
 
 ### From a local clone
 
@@ -69,7 +75,7 @@ Point config at the built files with absolute `file://` URLs:
 
 ## OpenCode setup
 
-If the `cursor` provider block is omitted, the classic plugin auto-registers it on startup (as **Cursor Integration**) using this package's entry. Model entries are filled from the local cache after you authenticate.
+If the `cursor` provider block is omitted, the classic plugin auto-registers it on startup (as **Cursor Integration**) using this package's entry. Model entries come from the local cache, which is filled after auth and again on startup when the cache is empty but credentials remain.
 
 For OpenCode builds that use the Effect/Promise **v2** plugin API (`plugins` field), also load:
 
@@ -96,7 +102,15 @@ Choose the **cursor** provider, then one of:
 | **Cursor account (browser login)** | PKCE OAuth — opens cursor.com to sign in |
 | **API key** | Paste a key from [cursor.com/settings](https://cursor.com/settings) (`sk-...`) |
 
-After login, the plugin fetches your available models and writes them to `cursor-models.json` (OpenCode config directory, or `CURSOR_CONFIG_DIR` if set).
+After login, the plugin fetches your available models and writes them to `~/.cache/opencode/cursor-models.json` (or `$XDG_CACHE_HOME/opencode/` when set). On later startups, if that cache is missing or empty but Cursor auth is still present, the plugin fetches again during config load.
+
+### Paths (XDG)
+
+| Kind | Default | Override |
+|------|---------|----------|
+| Model / version **cache** | `~/.cache/opencode/` | `$XDG_CACHE_HOME/opencode/` |
+| OpenCode **auth** (`auth.json`) | `~/.local/share/opencode/` | `$XDG_DATA_HOME/opencode/` |
+| OpenCode **config** (AGENTS, skills, …) | `~/.config/opencode/` | (config dir helper; not the model cache) |
 
 ### Select a model
 
@@ -126,11 +140,12 @@ Pass either `accessToken` (JWT from OAuth or key exchange) or `apiKey` (raw `sk-
 
 | Variable | Description |
 |----------|-------------|
-| `CURSOR_CONFIG_DIR` | Override directory for `cursor-models.json` cache (defaults to the OpenCode directory passed into the plugin) |
 | `CURSOR_WEBSITE_URL` | Override OAuth login base URL (default `https://cursor.com`) |
 | `CURSOR_API_BASE_URL` | Override API base for auth and model discovery (default `https://api2.cursor.sh`) |
 | `CURSOR_PROVIDER_DEBUG` | Set to `1` or `true` to enable wire-level debug logging |
 | `CURSOR_PROVIDER_DEBUG_FILE` | Debug log path (default `/tmp/cursor-provider-debug.log`) |
+| `XDG_CACHE_HOME` | When set, model/version caches go under `$XDG_CACHE_HOME/opencode/` instead of `~/.cache/opencode/` |
+| `XDG_DATA_HOME` | When set, OpenCode `auth.json` is read from `$XDG_DATA_HOME/opencode/` instead of `~/.local/share/opencode/` |
 
 `createCursor({ baseURL })` also overrides the agent Run host (default `https://agentn.global.api5.cursor.sh`).
 
@@ -181,10 +196,10 @@ OpenCode
 
 | Problem | What to try |
 |---------|-------------|
-| No Cursor models in the picker | Run `opencode auth login`, choose **cursor**, then restart OpenCode so the plugin reloads `cursor-models.json`. Confirm `provider.cursor.npm` is the package name (or a built `file://…/dist/index.js`). |
+| No Cursor models in the picker | Confirm Cursor auth (`opencode auth login` → **cursor**). Restart OpenCode — if auth is present and the cache is empty, models are fetched on startup. Confirm `provider.cursor.npm` is the package name (or a built `file://…/dist/index.js`). |
 | Auth / 401 errors mid-session | Re-login. OAuth and exchanged API-key JWTs refresh automatically when near expiry; a revoked refresh token needs a fresh login. |
 | “Too many connections from different devices” | Device IDs are derived from stable OS identifiers (same approach as the Cursor CLI). Avoid running multiple clients that invent different machine fingerprints for the same account. |
-| Empty or stale model list | Delete `cursor-models.json` under the OpenCode config dir (or the dir set by `CURSOR_CONFIG_DIR`) and re-auth / restart so models are fetched again. Cache TTL is 24h; a failed background refresh keeps serving the previous cache. |
+| Empty or stale model list | Delete `~/.cache/opencode/cursor-models.json` (or under `$XDG_CACHE_HOME/opencode/`) and restart OpenCode. Existing Cursor auth is enough to refill the cache; re-login only if auth itself is broken. Cache TTL is 24h; a failed background refresh keeps serving the previous cache. |
 | Stream hangs or HTTP/2 errors | Abort the turn and retry. The agent Run uses a bidirectional HTTP/2 stream to `agentn.global.api5.cursor.sh`; a dropped connection leaves the in-flight session unusable. |
 | Need wire-level logs | Set `CURSOR_PROVIDER_DEBUG=1` (optional `CURSOR_PROVIDER_DEBUG_FILE`, default `/tmp/cursor-provider-debug.log`) and reproduce the issue. |
 

package/dist/context/auth-store.d.ts

@@ -0,0 +1,21 @@
+/** Mirrors OpenCode / SDK OAuth + API auth used for Cursor. `wellknown` is not wired yet. */
+export type StoredAuth = {
+    type: "oauth";
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+    enterpriseUrl?: string;
+} | {
+    type: "api";
+    key: string;
+    metadata?: Record<string, string>;
+};
+/**
+ * Read a provider's credentials from OpenCode's `auth.json` (XDG data dir).
+ *
+ * Honors `OPENCODE_AUTH_CONTENT` when set — same injection hook OpenCode core
+ * uses in tests / embedded runs (not an SDK export).
+ */
+export declare function readStoredAuth(providerId: string): Promise<StoredAuth | undefined>;
+export declare function asStoredAuth(value: unknown): StoredAuth | undefined;

package/dist/context/auth-store.js

@@ -0,0 +1,64 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { opencodeGlobalDataDir } from "./paths.js";
+function debugEnabled() {
+    return process.env.CURSOR_PROVIDER_DEBUG === "1" || process.env.CURSOR_PROVIDER_DEBUG === "true";
+}
+function debugAuthStore(message) {
+    if (!debugEnabled())
+        return;
+    console.error(`[cursor-opencode-provider] auth-store: ${message}`);
+}
+/**
+ * Read a provider's credentials from OpenCode's `auth.json` (XDG data dir).
+ *
+ * Honors `OPENCODE_AUTH_CONTENT` when set — same injection hook OpenCode core
+ * uses in tests / embedded runs (not an SDK export).
+ */
+export async function readStoredAuth(providerId) {
+    if (process.env.OPENCODE_AUTH_CONTENT) {
+        try {
+            const data = JSON.parse(process.env.OPENCODE_AUTH_CONTENT);
+            return asStoredAuth(data[providerId]);
+        }
+        catch {
+            debugAuthStore("OPENCODE_AUTH_CONTENT is not valid JSON");
+            return undefined;
+        }
+    }
+    const filePath = path.join(opencodeGlobalDataDir(), "auth.json");
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        try {
+            const data = JSON.parse(raw);
+            return asStoredAuth(data[providerId]);
+        }
+        catch {
+            debugAuthStore("auth.json is not valid JSON");
+            return undefined;
+        }
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code !== "ENOENT") {
+            debugAuthStore(`failed to read auth.json (${code ?? "unknown"})`);
+        }
+        return undefined;
+    }
+}
+export function asStoredAuth(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const v = value;
+    if (v.type === "oauth" &&
+        typeof v.access === "string" &&
+        typeof v.refresh === "string" &&
+        typeof v.expires === "number") {
+        return value;
+    }
+    if (v.type === "api" && typeof v.key === "string") {
+        return value;
+    }
+    // wellknown is intentionally rejected until resolveAccessToken supports it
+    return undefined;
+}

package/dist/context/index.d.ts

@@ -1,2 +1,2 @@
 export { buildRequestContext, type BuildRequestContextInput } from "./build.js";
-export { opencodeGlobalConfigDir } from "./paths.js";
+export { opencodeGlobalCacheDir, opencodeGlobalConfigDir, opencodeGlobalDataDir } from "./paths.js";

package/dist/context/index.js

@@ -1,2 +1,2 @@
 export { buildRequestContext } from "./build.js";
-export { opencodeGlobalConfigDir } from "./paths.js";
+export { opencodeGlobalCacheDir, opencodeGlobalConfigDir, opencodeGlobalDataDir } from "./paths.js";

package/dist/context/paths.d.ts

@@ -1,3 +1,14 @@
 /** OpenCode global config dir (`~/.config/opencode`). */
 export declare function opencodeGlobalConfigDir(): string;
+/**
+ * OpenCode global cache dir (`~/.cache/opencode`).
+ * Uses `$XDG_CACHE_HOME/opencode` when set, otherwise `$HOME/.cache/opencode`.
+ */
+export declare function opencodeGlobalCacheDir(): string;
+/**
+ * OpenCode global data dir (`~/.local/share/opencode`).
+ * Uses `$XDG_DATA_HOME/opencode` when set, otherwise `$HOME/.local/share/opencode`.
+ * Auth credentials live here in `auth.json`.
+ */
+export declare function opencodeGlobalDataDir(): string;
 export declare function resolveHomeRelative(p: string): string;

package/dist/context/paths.js

@@ -1,8 +1,32 @@
 import { homedir } from "node:os";
 import path from "node:path";
+function resolveHome() {
+    return process.env.HOME || process.env.USERPROFILE || homedir();
+}
 /** OpenCode global config dir (`~/.config/opencode`). */
 export function opencodeGlobalConfigDir() {
-    return path.join(homedir(), ".config", "opencode");
+    return path.join(resolveHome(), ".config", "opencode");
+}
+/**
+ * OpenCode global cache dir (`~/.cache/opencode`).
+ * Uses `$XDG_CACHE_HOME/opencode` when set, otherwise `$HOME/.cache/opencode`.
+ */
+export function opencodeGlobalCacheDir() {
+    if (process.env.XDG_CACHE_HOME) {
+        return path.join(process.env.XDG_CACHE_HOME, "opencode");
+    }
+    return path.join(resolveHome(), ".cache", "opencode");
+}
+/**
+ * OpenCode global data dir (`~/.local/share/opencode`).
+ * Uses `$XDG_DATA_HOME/opencode` when set, otherwise `$HOME/.local/share/opencode`.
+ * Auth credentials live here in `auth.json`.
+ */
+export function opencodeGlobalDataDir() {
+    if (process.env.XDG_DATA_HOME) {
+        return path.join(process.env.XDG_DATA_HOME, "opencode");
+    }
+    return path.join(resolveHome(), ".local", "share", "opencode");
 }
 export function resolveHomeRelative(p) {
     if (p.startsWith("~/"))

package/dist/language-model.js

@@ -1,4 +1,3 @@
-import path from "node:path";
 import fs from "node:fs";
 import { createHash } from "node:crypto";
 import { bidiRunStream, trace } from "./transport/connect.js";
@@ -12,10 +11,11 @@ import { conversationBlobCount } from "./protocol/blob-store.js";
 import { sessionManager } from "./session.js";
 import { readCache, cacheFilePath, resolveVariantParameters } from "./models.js";
 import { buildRequestContext } from "./context/build.js";
+import { opencodeGlobalCacheDir } from "./context/paths.js";
 let _availableModels;
 // mtime of the cache file the last time we loaded it. Compared on each call
 // so discoverModels' background refresh is picked up without a process restart.
-let _availableModelsMtimeMs = 0;
+let _availableModelsMtimeMs = -1;
 export function createCursorLanguageModel(modelId, providerId, options) {
     return {
         specificationVersion: "v3",
@@ -301,11 +301,9 @@ export function findContinuationSession(toolResults) {
     return undefined;
 }
 async function loadAvailableModels() {
-    const configDir = resolveModelCacheDir();
-    if (!configDir)
-        return;
+    const cacheDir = opencodeGlobalCacheDir();
     try {
-        const filePath = cacheFilePath(configDir);
+        const filePath = cacheFilePath(cacheDir);
         let mtime = 0;
         try {
             const stat = await fs.promises.stat(filePath);
@@ -316,24 +314,13 @@ async function loadAvailableModels() {
         }
         // Re-read when the file changed (discoverModels background refresh).
         if (mtime !== _availableModelsMtimeMs) {
-            const cached = await readCache(configDir);
+            const cached = await readCache(cacheDir);
             _availableModels = cached?.models;
             _availableModelsMtimeMs = mtime;
         }
     }
     catch { /* ignore */ }
 }
-/** Same directory the plugin writes to (CURSOR_CONFIG_DIR, else OpenCode config). */
-function resolveModelCacheDir() {
-    if (process.env.CURSOR_CONFIG_DIR)
-        return process.env.CURSOR_CONFIG_DIR;
-    const home = process.env.HOME || process.env.USERPROFILE;
-    if (!home)
-        return undefined;
-    return process.env.XDG_CONFIG_HOME
-        ? path.join(process.env.XDG_CONFIG_HOME, "opencode")
-        : path.join(home, ".config", "opencode");
-}
 /**
  * Read the held-open stream, emitting stream parts, until the turn boundary:
  *  - a tool call (exec_server_message) → emit tool-call, finish "tool-calls",

package/dist/models.d.ts

@@ -24,9 +24,9 @@ export type ModelCache = {
     fetchedAt: number;
 };
 export declare function isCacheFresh(cache: ModelCache, ttlMs?: number): boolean;
-export declare function cacheFilePath(configDir: string): string;
-export declare function readCache(configDir: string): Promise<ModelCache | null>;
-export declare function writeCache(configDir: string, cache: ModelCache): Promise<void>;
+export declare function cacheFilePath(cacheDir: string): string;
+export declare function readCache(cacheDir: string): Promise<ModelCache | null>;
+export declare function writeCache(cacheDir: string, cache: ModelCache): Promise<void>;
 export declare function mapAvailableModelsResponse(raw: Record<string, unknown>): ModelInfo[];
 /**
  * Resolve the parameter values to send in `requested_model.parameters` for a
@@ -43,7 +43,7 @@ export declare function fetchModels(token: string, options?: {
     baseURL?: string;
     headers?: Record<string, string>;
 }): Promise<ModelInfo[]>;
-export declare function discoverModels(token: string, configDir: string, options?: {
+export declare function discoverModels(token: string, cacheDir: string, options?: {
     baseURL?: string;
     headers?: Record<string, string>;
 }): Promise<ModelInfo[]>;

package/dist/models.js

@@ -8,11 +8,11 @@ import path from "node:path";
 export function isCacheFresh(cache, ttlMs = MODEL_CACHE_TTL_MS) {
     return Date.now() - cache.fetchedAt < ttlMs;
 }
-export function cacheFilePath(configDir) {
-    return path.join(configDir, MODEL_CACHE_FILE);
+export function cacheFilePath(cacheDir) {
+    return path.join(cacheDir, MODEL_CACHE_FILE);
 }
-export async function readCache(configDir) {
-    const filePath = cacheFilePath(configDir);
+export async function readCache(cacheDir) {
+    const filePath = cacheFilePath(cacheDir);
     try {
         if (!existsSync(filePath))
             return null;
@@ -23,8 +23,8 @@ export async function readCache(configDir) {
         return null;
     }
 }
-export async function writeCache(configDir, cache) {
-    const filePath = cacheFilePath(configDir);
+export async function writeCache(cacheDir, cache) {
+    const filePath = cacheFilePath(cacheDir);
     await mkdir(path.dirname(filePath), { recursive: true });
     await writeFile(filePath, JSON.stringify(cache, null, 2), "utf-8");
 }
@@ -104,13 +104,13 @@ export async function fetchModels(token, options = {}) {
     const raw = await unaryAvailableModels(token, options);
     return mapAvailableModelsResponse(raw);
 }
-export async function discoverModels(token, configDir, options = {}) {
-    const cached = await readCache(configDir);
+export async function discoverModels(token, cacheDir, options = {}) {
+    const cached = await readCache(cacheDir);
     // Cache is fresh → return it; refresh in background
     if (cached && isCacheFresh(cached)) {
         // Background refresh (fire and forget)
         fetchModels(token, options)
-            .then((models) => writeCache(configDir, { models, fetchedAt: Date.now() }))
+            .then((models) => writeCache(cacheDir, { models, fetchedAt: Date.now() }))
             .catch(() => {
             /* background refresh failure is non-fatal */
         });
@@ -121,7 +121,7 @@ export async function discoverModels(token, configDir, options = {}) {
         try {
             const models = await fetchModels(token, options);
             const newCache = { models, fetchedAt: Date.now() };
-            await writeCache(configDir, newCache);
+            await writeCache(cacheDir, newCache);
             return models;
         }
         catch {
@@ -131,6 +131,6 @@ export async function discoverModels(token, configDir, options = {}) {
     // No cache → must fetch
     const models = await fetchModels(token, options);
     const newCache = { models, fetchedAt: Date.now() };
-    await writeCache(configDir, newCache);
+    await writeCache(cacheDir, newCache);
     return models;
 }

package/dist/plugin.d.ts

@@ -1,2 +1,15 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+import { type ModelInfo } from "./models.js";
+/**
+ * Display names shared by both a thinking and a non-thinking model. A thinking
+ * model with such a name needs a "Thinking" tag to disambiguate it from its
+ * non-thinking twin (Cursor's Claude/Fable/Sonnet families). Models whose names
+ * are already unique — including Cursor's GPT family, where the reasoning tier
+ * ("None"/"Low"/"High"…) is baked into the name — are excluded, so they aren't
+ * tagged redundantly.
+ */
+export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string>;
+export declare function modelInfoToConfig(mi: ModelInfo, options?: {
+    thinkingSuffix?: boolean;
+}): Record<string, any>;
 export declare function CursorPlugin(input: PluginInput): Promise<Hooks>;

package/dist/plugin.js

@@ -1,13 +1,36 @@
 import { CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
 import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtPayload } from "./auth.js";
-import { readCache, discoverModels } from "./models.js";
+import { readCache, discoverModels, isCacheFresh } from "./models.js";
+import { opencodeGlobalCacheDir } from "./context/paths.js";
+import { readStoredAuth } from "./context/auth-store.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
+/**
+ * Strip characters that break rendering in the OpenCode Desktop webview from a
+ * model or variant display name: HTML/markup chars (`< > & " ' \``), parentheses,
+ * Tabs/newlines collapse to single spaces; dots and unicode letters are preserved so names
+ * stay readable. Fixes https://github.com/oakimov/cursor-opencode-provider/issues/2.
+ */
+function safeLabel(value) {
+    return (value
+        .replace(/[()<>&"'`]/g, "")
+        .replace(/\s+/g, " ")
+        .trim() || "default");
+}
+function baseName(mi) {
+    return safeLabel(mi.displayName ?? mi.id);
+}
 function modelInfoVariants(mi) {
     if (mi.variants.length === 0)
         return undefined;
     const entries = {};
+    const usedKeys = new Set();
     for (const v of mi.variants) {
-        const key = v.displayName || v.key || "default";
+        const base = safeLabel(v.displayName || v.key || "default");
+        let key = base;
+        let suffix = 2;
+        while (usedKeys.has(key))
+            key = `${base}--${suffix++}`;
+        usedKeys.add(key);
         const params = {};
         for (const p of v.parameterValues) {
             params[p.id] = p.value;
@@ -16,9 +39,37 @@ function modelInfoVariants(mi) {
     }
     return entries;
 }
-function modelInfoToConfig(mi) {
+/**
+ * Display names shared by both a thinking and a non-thinking model. A thinking
+ * model with such a name needs a "Thinking" tag to disambiguate it from its
+ * non-thinking twin (Cursor's Claude/Fable/Sonnet families). Models whose names
+ * are already unique — including Cursor's GPT family, where the reasoning tier
+ * ("None"/"Low"/"High"…) is baked into the name — are excluded, so they aren't
+ * tagged redundantly.
+ */
+export function thinkingSuffixBaseNames(models) {
+    const flags = new Map();
+    for (const m of models) {
+        const base = baseName(m);
+        const entry = flags.get(base) ?? { hasThinking: false, hasNonThinking: false };
+        if (m.supportsThinking)
+            entry.hasThinking = true;
+        else
+            entry.hasNonThinking = true;
+        flags.set(base, entry);
+    }
+    const ambiguous = new Set();
+    for (const [base, f] of flags)
+        if (f.hasThinking && f.hasNonThinking)
+            ambiguous.add(base);
+    return ambiguous;
+}
+export function modelInfoToConfig(mi, options = {}) {
+    let name = baseName(mi);
+    if (options.thinkingSuffix)
+        name += " Thinking";
     const config = {
-        name: mi.displayName ?? mi.id,
+        name,
         reasoning: mi.supportsThinking ?? false,
         tool_call: mi.supportsAgent ?? true,
         temperature: false,
@@ -32,17 +83,131 @@ function modelInfoToConfig(mi) {
         config.variants = variants;
     return config;
 }
+function modelsToConfig(models) {
+    const ambiguous = thinkingSuffixBaseNames(models);
+    const out = {};
+    for (const m of models) {
+        out[m.id] = modelInfoToConfig(m, {
+            thinkingSuffix: !!m.supportsThinking && ambiguous.has(baseName(m)),
+        });
+    }
+    return out;
+}
 export async function CursorPlugin(input) {
-    const configDir = process.env.CURSOR_CONFIG_DIR || input.directory;
+    const cacheDir = opencodeGlobalCacheDir();
+    // Last access token successfully resolved in this plugin instance. Config's
+    // loadModels can only read OpenCode's durable store (auth.json /
+    // OPENCODE_AUTH_CONTENT); auth.loader gets live credentials via getAuth().
+    // Those usually match, but after a refresh where persistAuthBestEffort fails,
+    // getAuth() may still see the old credentials while we already hold a usable
+    // token here — keep it so the loader can still discover models.
+    let sessionAccessToken;
+    async function persistAuth(body) {
+        await input.client.auth.set({
+            path: { id: CURSOR_PROVIDER_ID },
+            body,
+        });
+    }
+    /** Persist refreshed credentials without failing the caller that already holds a live token. */
+    async function persistAuthBestEffort(body) {
+        try {
+            await persistAuth(body);
+        }
+        catch {
+            // ignore — token is still usable for this process
+        }
+    }
+    /**
+     * Durable credentials OpenCode stores on disk (same file getAuth() reads in
+     * the normal path). Used from `config`, which has no getAuth() callback.
+     */
+    async function authFromStore() {
+        return readStoredAuth(CURSOR_PROVIDER_ID);
+    }
+    /**
+     * Prefer OpenCode's live getAuth(); fall back to the durable store so loader
+     * and config share the same underlying credentials when possible.
+     */
+    async function authForLoader(getAuth) {
+        return (await getAuth()) ?? (await authFromStore());
+    }
+    async function resolveAccessToken(auth) {
+        if (auth.type === "api") {
+            let accessToken = auth.key;
+            const refreshToken = auth.metadata?.refreshToken;
+            // API-key exchange returns a short-lived JWT stored as `key`. Refresh
+            // it the same way as OAuth when it is expiring / already expired.
+            if (refreshToken && isExpiringSoon(auth.key)) {
+                try {
+                    const newTokens = await refreshAccessToken(refreshToken);
+                    accessToken = newTokens.accessToken;
+                    await persistAuthBestEffort({
+                        type: "api",
+                        key: newTokens.accessToken,
+                        metadata: {
+                            ...auth.metadata,
+                            refreshToken: newTokens.refreshToken,
+                        },
+                    });
+                }
+                catch {
+                    // refresh failed — keep the existing key; the next call may still work
+                }
+            }
+            if (accessToken)
+                sessionAccessToken = accessToken;
+            return accessToken;
+        }
+        if (auth.type === "oauth") {
+            if (!isExpiringSoon(auth.access)) {
+                sessionAccessToken = auth.access;
+                return auth.access;
+            }
+            if (!auth.refresh)
+                return undefined;
+            try {
+                const newTokens = await refreshAccessToken(auth.refresh);
+                // Preserve optional OAuth fields (v2 Auth / plugin may carry these).
+                const extras = auth;
+                // Use the new token even if persisting back to OpenCode fails.
+                await persistAuthBestEffort({
+                    type: "oauth",
+                    access: newTokens.accessToken,
+                    refresh: newTokens.refreshToken,
+                    expires: decodeExpFromJwt(newTokens.accessToken),
+                    ...(extras.accountId !== undefined ? { accountId: extras.accountId } : {}),
+                    ...(extras.enterpriseUrl !== undefined ? { enterpriseUrl: extras.enterpriseUrl } : {}),
+                });
+                sessionAccessToken = newTokens.accessToken;
+                return newTokens.accessToken;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
     async function loadModels() {
-        const cached = await readCache(configDir);
-        if (!cached || cached.models.length === 0)
+        const cached = await readCache(cacheDir);
+        if (!cached || cached.models.length === 0) {
+            // Config runs before auth.loader and has no getAuth(); read the durable
+            // store (normally the same source getAuth() uses).
+            const auth = await authFromStore();
+            if (auth) {
+                const accessToken = await resolveAccessToken(auth);
+                if (accessToken) {
+                    try {
+                        const models = await discoverModels(accessToken, cacheDir);
+                        return modelsToConfig(models);
+                    }
+                    catch {
+                        // discovery failed — leave the list empty
+                    }
+                }
+            }
             return {};
-        const models = {};
-        for (const m of cached.models) {
-            models[m.id] = modelInfoToConfig(m);
         }
-        return models;
+        return modelsToConfig(cached.models);
     }
     return {
         async config(cfg) {
@@ -130,60 +295,19 @@ export async function CursorPlugin(input) {
                 },
             ],
             async loader(getAuth) {
-                const auth = await getAuth();
-                if (!auth)
-                    return {};
-                let accessToken;
-                if (auth.type === "api") {
-                    accessToken = auth.key;
-                    const refreshToken = auth.metadata?.refreshToken;
-                    // API-key exchange returns a short-lived JWT stored as `key`. Refresh
-                    // it the same way as OAuth when it is expiring / already expired.
-                    if (refreshToken && isExpiringSoon(auth.key)) {
-                        try {
-                            const newTokens = await refreshAccessToken(refreshToken);
-                            await input.client.auth.set({
-                                path: { id: CURSOR_PROVIDER_ID },
-                                body: {
-                                    type: "api",
-                                    key: newTokens.accessToken,
-                                    metadata: { refreshToken: newTokens.refreshToken },
-                                },
-                            });
-                            accessToken = newTokens.accessToken;
-                        }
-                        catch {
-                            // refresh failed — keep the existing key; the next call may still work
-                        }
-                    }
-                }
-                else if (auth.type === "oauth") {
-                    if (!isExpiringSoon(auth.access)) {
-                        accessToken = auth.access;
-                    }
-                    else if (auth.refresh) {
-                        try {
-                            const newTokens = await refreshAccessToken(auth.refresh);
-                            await input.client.auth.set({
-                                path: { id: CURSOR_PROVIDER_ID },
-                                body: {
-                                    type: "oauth",
-                                    access: newTokens.accessToken,
-                                    refresh: newTokens.refreshToken,
-                                    expires: decodeExpFromJwt(newTokens.accessToken),
-                                },
-                            });
-                            accessToken = newTokens.accessToken;
-                        }
-                        catch {
-                            // refresh failed
-                        }
-                    }
-                }
+                const auth = await authForLoader(getAuth);
+                // Prefer credentials from getAuth/store; if refresh already succeeded in
+                // loadModels but persist failed, fall back to the in-memory session token.
+                const accessToken = (auth ? await resolveAccessToken(auth) : undefined) ?? sessionAccessToken;
                 if (accessToken) {
-                    // Use discoverModels so we respect TTL / serve-stale semantics and
-                    // write through the same cache path language-model reads.
-                    discoverModels(accessToken, configDir).catch(() => { });
+                    // Skip when config already filled a fresh cache (avoids a second
+                    // AvailableModels round-trip + background refresh on cold start).
+                    const cached = await readCache(cacheDir);
+                    if (!cached || cached.models.length === 0 || !isCacheFresh(cached)) {
+                        // Await so an empty/missing cache is written before the loader returns
+                        // (fire-and-forget often loses the race on short-lived CLI commands).
+                        await discoverModels(accessToken, cacheDir).catch(() => { });
+                    }
                 }
                 return {
                     ...(accessToken ? { accessToken } : {}),

package/dist/protocol/client-version.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { FALLBACK_CLIENT_VERSION, MODEL_CACHE_TTL_MS, VERSION_CACHE_FILE, } from "../shared.js";
+import { opencodeGlobalCacheDir } from "../context/paths.js";
 const INSTALL_URL = "https://cursor.com/install";
 const REMOTE_TIMEOUT_MS = 5_000;
 const BUILD_RE = /^\d{4}\.\d{2}\.\d{2}-[0-9A-Za-z][0-9A-Za-z.-]*$/;
@@ -69,24 +70,11 @@ export function extractVersionFromInstaller(script) {
     const match = script.match(/downloads\.cursor\.com\/lab\/([^/"'\s]+)\//);
     return match && BUILD_RE.test(match[1]) ? match[1] : undefined;
 }
-function resolveCacheDir() {
-    if (process.env.CURSOR_CONFIG_DIR)
-        return process.env.CURSOR_CONFIG_DIR;
-    const home = process.env.HOME || process.env.USERPROFILE;
-    if (!home)
-        return undefined;
-    return process.env.XDG_CONFIG_HOME
-        ? path.join(process.env.XDG_CONFIG_HOME, "opencode")
-        : path.join(home, ".config", "opencode");
-}
 function versionCachePath() {
-    const dir = resolveCacheDir();
-    return dir ? path.join(dir, VERSION_CACHE_FILE) : undefined;
+    return path.join(opencodeGlobalCacheDir(), VERSION_CACHE_FILE);
 }
 function readVersionCache() {
     const file = versionCachePath();
-    if (!file)
-        return undefined;
     try {
         const value = JSON.parse(fs.readFileSync(file, "utf8"));
         if (!isClientVersion(value.version) ||
@@ -102,8 +90,6 @@ function readVersionCache() {
 }
 function writeVersionCache(cache) {
     const file = versionCachePath();
-    if (!file)
-        return;
     try {
         fs.mkdirSync(path.dirname(file), { recursive: true });
         fs.writeFileSync(file, JSON.stringify(cache, null, 2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",