cursor-opencode-provider 0.1.5 → 0.2.1

package/README.md

@@ -47,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.5"`.
+Pin a version if you want: `"cursor-opencode-provider@0.2.1"`.
 
 ### From a local clone
 
@@ -102,7 +102,7 @@ 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 `~/.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.
+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, a missing, empty, expired, or old-schema cache is refreshed during config load when Cursor auth is available; an existing stale cache remains usable if refresh fails.
 
 ### Paths (XDG)
 
@@ -114,12 +114,37 @@ After login, the plugin fetches your available models and writes them to `~/.cac
 
 ### Select a model
 
-Pick a model from the cached list (for example `composer-2.5`, `default`, or a Claude/GPT variant exposed by your subscription):
+Pick a model from the cached list (for example `composer-2.5`, `default`, or a Claude/GPT model exposed by your subscription):
 
 ```bash
 opencode run --model cursor/composer-2.5 "Hello from Cursor via OpenCode"
 ```
 
+#### Variants
+
+Cursor models often expose parameterized variants (effort, thinking, fast, context tier, …). The plugin materializes those as OpenCode **model variants**. In the TUI, pick one from the variant dialog or cycle with OpenCode’s `variant_cycle` keybind (default `ctrl+t`).
+
+The selected variant’s Cursor parameter map is forwarded on the Run as `requested_model.parameters` (isolated under `providerOptions.cursor.cursorVariantParameters` so unrelated OpenCode options are not leaked onto the wire).
+
+#### 1M / long context
+
+OpenCode’s context limit is static per model entry, while Cursor’s long-context tier is a variant parameter (`context=1m`). When a model has both a base tier and a `1m` tier, the plugin emits a separate OpenCode entry `<model-id>-1m` (for example `claude-opus-4-8-1m`) with:
+
+- `limit.context` set to the 1M window (so overflow checks and compaction match the tier)
+- only the long-context variants in its picker
+- the real Cursor model id carried in `options.cursorModelId` (not `config.id`, which would make OpenCode merge base variants into the 1M entry)
+
+The Run still uses Cursor’s original model id; OpenCode’s synthetic `-1m` id is only for picking and limits.
+
+#### Max mode
+
+Cursor IDE has a separate **Max Mode** toggle that sets `requested_model.max_mode` and selects the default max / 1m variant. OpenCode has no equivalent custom toggle, so this provider approximates it:
+
+- Selecting a `*-1m` model (or any resolved params with `context=1m`) sets wire `max_mode` to `true`
+- An explicit `providerOptions.cursor.maxMode` hint also turns it on
+
+There is no independent Max Mode chrome in OpenCode beyond choosing the 1M model / long-context variant.
+
 ## Programmatic usage
 
 ```ts
@@ -219,4 +244,4 @@ OpenCode
 
 ## License
 
-MIT
+MIT

package/dist/language-model.js

@@ -10,7 +10,7 @@ import { handleKvServerMessage } from "./protocol/kv.js";
 import { getCheckpoint, setCheckpoint } from "./protocol/checkpoint.js";
 import { conversationBlobCount } from "./protocol/blob-store.js";
 import { sessionManager } from "./session.js";
-import { readCache, cacheFilePath, resolveVariantParameters } from "./models.js";
+import { readCache, cacheFilePath, resolveVariantParameters, paramsImplyMaxMode, extractCursorVariantParameters, resolveCursorWireModelId } from "./models.js";
 import { buildRequestContext } from "./context/build.js";
 import { opencodeGlobalCacheDir } from "./context/paths.js";
 import { resolveAgentUrl } from "./agent-url.js";
@@ -184,10 +184,24 @@ async function startSession(modelId, token, callOptions, options) {
             telemetryEnabled: resolveTelemetryEnabled(options),
         }));
     const providerOptions = callOptions.providerOptions?.cursor;
-    const reasoningEffort = providerOptions?.reasoningEffort;
-    const maxMode = !!(providerOptions?.maxMode ?? false);
-    const modelInfo = _availableModels?.find((m) => m.id === modelId);
-    const parameterValues = resolveVariantParameters(modelInfo, { reasoningEffort, maxMode });
+    // OpenCode merges model, agent, and selected-variant options before placing
+    // them under providerOptions.cursor. Read only the plugin's dedicated nested
+    // payload so unrelated options never become requested_model.parameters.
+    const picked = extractCursorVariantParameters(providerOptions);
+    const cursorModelId = resolveCursorWireModelId(providerOptions, modelId);
+    const reasoningEffort = typeof providerOptions?.reasoningEffort === "string"
+        ? providerOptions.reasoningEffort
+        : undefined;
+    const hintMaxMode = !!(providerOptions?.maxMode ?? false);
+    const modelInfo = _availableModels?.find((m) => m.id === cursorModelId);
+    const parameterValues = resolveVariantParameters(modelInfo, {
+        reasoningEffort,
+        maxMode: hintMaxMode,
+        picked,
+    });
+    // Wire max_mode from the hint *or* a 1m context pick — OpenCode's variant
+    // paramMap does not include a maxMode key when the user selects 1m.
+    const maxMode = hintMaxMode || paramsImplyMaxMode(parameterValues);
     // Do NOT pass callOptions.abortSignal into the h2 Run stream. OpenCode aborts
     // that signal when a turn ends with tool-calls; the Cursor stream must stay
     // open until we write the exec results on the next doStream.
@@ -208,7 +222,7 @@ async function startSession(modelId, token, callOptions, options) {
     const conversationState = getCheckpoint(conversationId);
     const reqBytes = buildRunRequest({
         text: userText,
-        modelId,
+        modelId: cursorModelId,
         conversationId,
         systemPrompt: conversationState ? undefined : systemPrompt,
         conversationState,
@@ -227,7 +241,7 @@ async function startSession(modelId, token, callOptions, options) {
     const hooksCtx = typeof requestContext.hooks_additional_context === "string"
         ? requestContext.hooks_additional_context
         : "";
-    trace(`outbound Run: model=${modelId} conversationId=${conversationId} ` +
+    trace(`outbound Run: model=${cursorModelId} opencodeModel=${modelId} conversationId=${conversationId} ` +
         `params=${JSON.stringify(parameterValues ?? [])} ` +
         `maxMode=${maxMode} systemPromptLen=${systemPrompt?.length ?? 0} tools=${tools.length} ` +
         `skills=${skillsCount} hooks=${hooksCtx ? hooksCtx.split("\n").length : 0} ` +

package/dist/models.d.ts

@@ -2,6 +2,10 @@ export type ModelParameterValue = {
     id: string;
     value: string;
 };
+/** Dedicated OpenCode provider-option key for a selected Cursor variant. */
+export declare const CURSOR_VARIANT_PARAMETERS_KEY = "cursorVariantParameters";
+/** Real Cursor model id used when an OpenCode entry has a synthetic id. */
+export declare const CURSOR_WIRE_MODEL_ID_KEY = "cursorModelId";
 export type ModelVariant = {
     key: string;
     parameterValues: ModelParameterValue[];
@@ -16,13 +20,27 @@ export type ModelInfo = {
     supportsThinking?: boolean;
     supportsAgent?: boolean;
     maxContext?: number;
+    /** Context window when max-mode is on (proto field 16). */
+    maxContextForMaxMode?: number;
     supportsMaxMode?: boolean;
     variants: ModelVariant[];
 };
 export type ModelCache = {
     models: ModelInfo[];
     fetchedAt: number;
+    /** Absent or mismatched → treat cache as stale (forces AvailableModels refetch). */
+    schemaVersion?: number;
 };
+/**
+ * Read only the dedicated variant payload generated by the plugin. OpenCode
+ * merges model, agent, and variant options into one providerOptions namespace;
+ * treating that whole object as Cursor parameters would leak unrelated options
+ * onto the wire.
+ */
+export declare function extractCursorVariantParameters(providerOptions: Record<string, unknown> | undefined): ModelParameterValue[] | undefined;
+export declare function resolveCursorWireModelId(providerOptions: Record<string, unknown> | undefined, fallback: string): string;
+/** True when resolved params select the long-context (1m) tier. */
+export declare function paramsImplyMaxMode(params: ModelParameterValue[]): boolean;
 export declare function isCacheFresh(cache: ModelCache, ttlMs?: number): boolean;
 export declare function cacheFilePath(cacheDir: string): string;
 export declare function readCache(cacheDir: string): Promise<ModelCache | null>;
@@ -30,14 +48,21 @@ export declare function writeCache(cacheDir: string, cache: ModelCache): Promise
 export declare function mapAvailableModelsResponse(raw: Record<string, unknown>): ModelInfo[];
 /**
  * Resolve the parameter values to send in `requested_model.parameters` for a
- * given model + requested reasoning effort. Each variant already carries the
- * full `{id,value}` set (per-model vocabulary), so we pick the matching variant
- * and return its parameters verbatim — the client never constructs these by
- * hand.
+ * given model + the variant opencode selected. Each variant already carries
+ * the full `{id,value}` set (per-model vocabulary — effort, fast, thinking,
+ * context, …), so we pick the matching variant and return its parameters
+ * verbatim — the client never constructs these by hand.
+ *
+ * `picked` is the user-selected variant paramMap (opencode sends it under
+ * `providerOptions.cursor`); when present it wins over effort/maxMode hints
+ * so every param the user chose (context, fast, …) is forwarded to Cursor.
+ * Hints (`reasoningEffort`, `maxMode`) live beside the dedicated picked array,
+ * so the picked values are already isolated and can be matched verbatim.
  */
 export declare function resolveVariantParameters(model: ModelInfo | undefined, opts?: {
     reasoningEffort?: string;
     maxMode?: boolean;
+    picked?: ModelParameterValue[];
 }): ModelParameterValue[];
 export declare function fetchModels(token: string, options?: {
     baseURL?: string;

package/dist/models.js

@@ -1,11 +1,69 @@
-import { MODEL_CACHE_FILE, MODEL_CACHE_TTL_MS } from "./shared.js";
+import { MODEL_CACHE_FILE, MODEL_CACHE_SCHEMA_VERSION, MODEL_CACHE_TTL_MS } from "./shared.js";
 import { unaryAvailableModels } from "./transport/connect.js";
 import { buildRequestedModelParams } from "./protocol/thinking.js";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import path from "node:path";
+/** Dedicated OpenCode provider-option key for a selected Cursor variant. */
+export const CURSOR_VARIANT_PARAMETERS_KEY = "cursorVariantParameters";
+/** Real Cursor model id used when an OpenCode entry has a synthetic id. */
+export const CURSOR_WIRE_MODEL_ID_KEY = "cursorModelId";
+/**
+ * Read only the dedicated variant payload generated by the plugin. OpenCode
+ * merges model, agent, and variant options into one providerOptions namespace;
+ * treating that whole object as Cursor parameters would leak unrelated options
+ * onto the wire.
+ */
+export function extractCursorVariantParameters(providerOptions) {
+    const raw = providerOptions?.[CURSOR_VARIANT_PARAMETERS_KEY];
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    const params = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return undefined;
+        const { id, value } = item;
+        if (typeof id !== "string" || typeof value !== "string")
+            return undefined;
+        params.push({ id, value });
+    }
+    return params;
+}
+export function resolveCursorWireModelId(providerOptions, fallback) {
+    const value = providerOptions?.[CURSOR_WIRE_MODEL_ID_KEY];
+    return typeof value === "string" && value.trim() ? value : fallback;
+}
+/** True when resolved params select the long-context (1m) tier. */
+export function paramsImplyMaxMode(params) {
+    return params.some((p) => p.id === "context" && p.value === "1m");
+}
+// Cursor encodes a model's context window as a variant parameter `id: "context"`
+// whose value is a tier string — the same 200k / 272k / 300k / 1m the IDE's
+// picker shows. The base tier rides on the default non-max variant; the 1M
+// tier (when the model supports max mode) rides on the default max variant.
+// `context_token_limit` (#15) / `context_token_limit_for_max_mode` (#16) are
+// also defined on AvailableModel but the server often leaves them empty — the
+// variant param is the primary source (request flags may still populate them).
+const CONTEXT_TIER_TO_TOKENS = {
+    "200k": 200_000,
+    "272k": 272_000,
+    "300k": 300_000,
+    "1m": 1_000_000,
+};
+function variantContextTokens(v) {
+    const raw = v?.parameterValues.find((p) => p.id === "context")?.value;
+    if (!raw)
+        return undefined;
+    const mapped = CONTEXT_TIER_TO_TOKENS[raw];
+    if (mapped !== undefined)
+        return mapped;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
 // ── Cache helpers ──
 export function isCacheFresh(cache, ttlMs = MODEL_CACHE_TTL_MS) {
+    if (cache.schemaVersion !== MODEL_CACHE_SCHEMA_VERSION)
+        return false;
     return Date.now() - cache.fetchedAt < ttlMs;
 }
 export function cacheFilePath(cacheDir) {
@@ -53,12 +111,22 @@ export function mapAvailableModelsResponse(raw) {
                 isDefaultMax: !!(v.isDefaultMaxConfig ?? v.is_default_max_config ?? false),
             });
         }
+        // Derive the context window from the variant `context` param (primary
+        // source). Base tier ← default non-max variant; max tier ← default max
+        // variant. Fall back to the (often empty) proto fields, then undefined.
+        // Prefer a non-1m context when isDefaultNonMax is missing so a leading
+        // max-mode variant cannot inflate the base window.
+        const variantBaseContext = variantContextTokens(variants.find((v) => v.isDefaultNonMax)) ??
+            variantContextTokens(variants.find((v) => v.parameterValues.some((p) => p.id === "context" && p.value !== "1m"))) ??
+            variantContextTokens(variants.find((v) => v.parameterValues.some((p) => p.id === "context")));
+        const variantMaxContext = variantContextTokens(variants.find((v) => v.isDefaultMax));
         models.push({
             id: name,
             displayName: (e.clientDisplayName ?? e.client_display_name ?? name),
             supportsThinking: !!(e.supportsThinking ?? e.supports_thinking ?? false),
             supportsAgent: !!(e.supportsAgent ?? e.supports_agent ?? false),
-            maxContext: (e.contextTokenLimit ?? e.context_token_limit ?? undefined),
+            maxContext: (variantBaseContext ?? e.contextTokenLimit ?? e.context_token_limit ?? undefined),
+            maxContextForMaxMode: (variantMaxContext ?? e.contextTokenLimitForMaxMode ?? e.context_token_limit_for_max_mode ?? undefined),
             supportsMaxMode: !!(e.supportsMaxMode ?? e.supports_max_mode ?? false),
             variants,
         });
@@ -68,23 +136,54 @@ export function mapAvailableModelsResponse(raw) {
 // ── Variant resolution ──
 /**
  * Resolve the parameter values to send in `requested_model.parameters` for a
- * given model + requested reasoning effort. Each variant already carries the
- * full `{id,value}` set (per-model vocabulary), so we pick the matching variant
- * and return its parameters verbatim — the client never constructs these by
- * hand.
+ * given model + the variant opencode selected. Each variant already carries
+ * the full `{id,value}` set (per-model vocabulary — effort, fast, thinking,
+ * context, …), so we pick the matching variant and return its parameters
+ * verbatim — the client never constructs these by hand.
+ *
+ * `picked` is the user-selected variant paramMap (opencode sends it under
+ * `providerOptions.cursor`); when present it wins over effort/maxMode hints
+ * so every param the user chose (context, fast, …) is forwarded to Cursor.
+ * Hints (`reasoningEffort`, `maxMode`) live beside the dedicated picked array,
+ * so the picked values are already isolated and can be matched verbatim.
  */
 export function resolveVariantParameters(model, opts = {}) {
+    const picked = opts.picked?.length ? opts.picked.map((p) => ({ ...p })) : undefined;
     if (!model || model.variants.length === 0) {
-        // No variant metadata: fall back to a bare effort param if requested.
+        if (picked?.length)
+            return picked;
         return opts.reasoningEffort ? [{ id: "effort", value: opts.reasoningEffort }] : [];
     }
     const effortOf = (v) => v.parameterValues.find((p) => p.id === "effort" || p.id === "reasoning")?.value;
     const isFast = (v) => v.parameterValues.find((p) => p.id === "fast")?.value === "true";
+    const contextOf = (v) => v.parameterValues.find((p) => p.id === "context")?.value;
+    const isMaxVariant = (v) => v.isDefaultMax || contextOf(v) === "1m";
     const wantMax = opts.maxMode ?? false;
-    const candidates = model.variants.filter((v) => !isFast(v));
-    const pool = candidates.length > 0 ? candidates : model.variants;
+    // Non-fast pool for hint-based resolution only. Exact `picked` matching
+    // searches all variants so Fast selections are not silently dropped.
+    const pool = model.variants.filter((v) => !isFast(v));
+    const scoped = pool.length > 0 ? pool : model.variants;
+    // 1. Variant explicitly picked by opencode (verbatim — preserves context, fast, …).
+    if (picked?.length) {
+        const signature = new Set(picked.map((p) => `${p.id}=${p.value}`));
+        const exact = model.variants.find((v) => v.parameterValues.every((p) => signature.has(`${p.id}=${p.value}`)) &&
+            signature.size === v.parameterValues.length);
+        if (exact) {
+            return buildRequestedModelParams(exact.parameterValues, {
+                reasoningEffort: opts.reasoningEffort,
+                maxMode: wantMax,
+            });
+        }
+        // Unmatched: forward the stripped pick so the TUI choice is not discarded.
+        return picked;
+    }
+    // When maxMode is requested, prefer max-tier variants for effort matching
+    // so "high + max" lands on 1m high rather than the first 300k high.
+    const maxScoped = wantMax ? scoped.filter(isMaxVariant) : [];
+    const effortPool = maxScoped.length > 0 ? maxScoped : scoped;
+    // 2. Effort hint (e.g. user passed reasoningEffort through the CLI).
     if (opts.reasoningEffort) {
-        const match = pool.find((v) => effortOf(v) === opts.reasoningEffort);
+        const match = effortPool.find((v) => effortOf(v) === opts.reasoningEffort);
         if (match) {
             return buildRequestedModelParams(match.parameterValues, {
                 reasoningEffort: opts.reasoningEffort,
@@ -92,11 +191,17 @@ export function resolveVariantParameters(model, opts = {}) {
             });
         }
     }
-    const byDefault = pool.find((v) => (wantMax ? v.isDefaultMax : v.isDefaultNonMax));
-    const base = (byDefault ?? pool[0]).parameterValues;
-    return buildRequestedModelParams(base, {
+    // 3. Max-mode hint → prefer the default max variant (1m context).
+    if (wantMax) {
+        const max = scoped.find((v) => v.isDefaultMax) ?? scoped.find((v) => contextOf(v) === "1m");
+        if (max)
+            return buildRequestedModelParams(max.parameterValues, { maxMode: true });
+    }
+    // 4. Default non-max variant.
+    const byDefault = scoped.find((v) => v.isDefaultNonMax) ?? scoped[0];
+    return buildRequestedModelParams(byDefault.parameterValues, {
         reasoningEffort: opts.reasoningEffort,
-        maxMode: wantMax,
+        maxMode: false,
     });
 }
 // ── Fetch + cache orchestration ──
@@ -110,7 +215,11 @@ export async function discoverModels(token, cacheDir, options = {}) {
     if (cached && isCacheFresh(cached)) {
         // Background refresh (fire and forget)
         fetchModels(token, options)
-            .then((models) => writeCache(cacheDir, { models, fetchedAt: Date.now() }))
+            .then((models) => writeCache(cacheDir, {
+            models,
+            fetchedAt: Date.now(),
+            schemaVersion: MODEL_CACHE_SCHEMA_VERSION,
+        }))
             .catch(() => {
             /* background refresh failure is non-fatal */
         });
@@ -120,7 +229,11 @@ export async function discoverModels(token, cacheDir, options = {}) {
     if (cached) {
         try {
             const models = await fetchModels(token, options);
-            const newCache = { models, fetchedAt: Date.now() };
+            const newCache = {
+                models,
+                fetchedAt: Date.now(),
+                schemaVersion: MODEL_CACHE_SCHEMA_VERSION,
+            };
             await writeCache(cacheDir, newCache);
             return models;
         }
@@ -130,7 +243,11 @@ export async function discoverModels(token, cacheDir, options = {}) {
     }
     // No cache → must fetch
     const models = await fetchModels(token, options);
-    const newCache = { models, fetchedAt: Date.now() };
+    const newCache = {
+        models,
+        fetchedAt: Date.now(),
+        schemaVersion: MODEL_CACHE_SCHEMA_VERSION,
+    };
     await writeCache(cacheDir, newCache);
     return models;
 }

package/dist/plugin.d.ts

@@ -11,5 +11,7 @@ import { type ModelInfo } from "./models.js";
 export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string>;
 export declare function modelInfoToConfig(mi: ModelInfo, options?: {
     thinkingSuffix?: boolean;
+    contextTier?: "base" | "long";
 }): Record<string, any>;
+export declare function modelsToConfig(models: ModelInfo[]): Record<string, any>;
 export declare function CursorPlugin(input: PluginInput): Promise<Hooks>;

package/dist/plugin.js

@@ -1,18 +1,25 @@
 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, isCacheFresh } from "./models.js";
+import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, readCache, discoverModels, isCacheFresh } from "./models.js";
 import { opencodeGlobalCacheDir } from "./context/paths.js";
 import { readStoredAuth } from "./context/auth-store.js";
 import { resolveAgentUrl } from "./agent-url.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.
+ * Strip characters and markup that break rendering in the OpenCode TUI/GUI from
+ * a model or variant display name:
+ *   • HTML tags (e.g. `<span style="…">Medium</span>`) — the IDE colours variant
+ *     suffixes with a CSS var that doesn't exist in OpenCode, so the raw markup
+ *     would show as literal text. We drop the tags and keep the inner text
+ *     ("Medium").
+ *   • 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(/[()<>&"'`]/g, "")
         .replace(/\s+/g, " ")
         .trim() || "default");
@@ -20,26 +27,69 @@ function safeLabel(value) {
 function baseName(mi) {
     return safeLabel(mi.displayName ?? mi.id);
 }
-function modelInfoVariants(mi) {
-    if (mi.variants.length === 0)
+function modelInfoVariants(mi, variants) {
+    if (variants.length === 0)
         return undefined;
     const entries = {};
     const usedKeys = new Set();
-    for (const v of mi.variants) {
-        const base = safeLabel(v.displayName || v.key || "default");
-        let key = base;
-        let suffix = 2;
+    const baseName = safeLabel(mi.displayName ?? mi.id);
+    // Each variant's key is `safeLabel(displayName)` (the IDE's own label, e.g.
+    // "Opus 4.8 1M High Fast Thinking") so the picker matches what the user
+    // sees in Cursor. Two variants can sanitize to the same name when the IDE
+    // wraps a differentiator in `<span>…</span>` (e.g. Composer's "Fast"
+    // suffix collapses to the bare model name after stripping). To guarantee
+    // every variant stays pickable:
+    //   1. If the sanitized displayName matches the model name itself, suffix
+    //      it with distinguishing params (or "default") so it never collides
+    //      with the model entry in the variant panel.
+    //   2. If two variants still collide, tag the later one with its params.
+    // Suffixes must stay free of `()` / markup chars — same constraint as
+    // safeLabel (issue #2); use spaced tokens, not parenthetical tags.
+    const tagDims = (p) => {
+        const labels = [];
+        for (const d of p) {
+            if (d.id === "fast" && d.value === "true")
+                labels.push("Fast");
+            else if (d.id === "thinking" && d.value === "true")
+                labels.push("Thinking");
+            else if (d.id === "context")
+                labels.push(d.value);
+        }
+        if (labels.length > 0)
+            return ` ${labels.join(" ")}`;
+        // No params at all — still disambiguate from the model name itself.
+        if (p.length === 0)
+            return "";
+        return " default";
+    };
+    for (const v of variants) {
+        const sanitized = safeLabel(v.displayName || v.key || "default");
+        let key = sanitized;
+        // Never let a variant key equal the model name — that would make the
+        // variant entry indistinguishable from the model entry in pickers that
+        // collapse them.
+        if (key === baseName && !usedKeys.has(key)) {
+            key = `${baseName}${tagDims(v.parameterValues)}` || `${baseName} default`;
+        }
+        else if (usedKeys.has(key)) {
+            key = `${sanitized}${tagDims(v.parameterValues)}`;
+        }
+        let n = 2;
         while (usedKeys.has(key))
-            key = `${base}--${suffix++}`;
+            key = `${sanitized}${tagDims(v.parameterValues)} ${n++}`;
         usedKeys.add(key);
-        const params = {};
-        for (const p of v.parameterValues) {
-            params[p.id] = p.value;
-        }
-        entries[key] = params;
+        entries[key] = {
+            [CURSOR_VARIANT_PARAMETERS_KEY]: v.parameterValues.map((p) => ({ ...p })),
+        };
     }
     return entries;
 }
+function isLongContextVariant(v) {
+    return v.parameterValues.some((p) => p.id === "context" && p.value === "1m");
+}
+function variantsForTier(mi, tier) {
+    return mi.variants.filter((v) => isLongContextVariant(v) === (tier === "long"));
+}
 /**
  * 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
@@ -66,31 +116,66 @@ export function thinkingSuffixBaseNames(models) {
     return ambiguous;
 }
 export function modelInfoToConfig(mi, options = {}) {
+    const contextTier = options.contextTier ?? "base";
+    const variants = variantsForTier(mi, contextTier);
     let name = baseName(mi);
     if (options.thinkingSuffix)
         name += " Thinking";
+    if (contextTier === "long")
+        name += " 1M";
+    // OpenCode's context limit is static per model entry, while Cursor's context
+    // tier is a variant parameter. Long-context choices are therefore emitted as
+    // separate OpenCode entries by modelsToConfig.
+    const context = contextTier === "long"
+        ? (mi.maxContextForMaxMode ?? 1_000_000)
+        : (mi.maxContext ?? 200_000);
     const config = {
         name,
         reasoning: mi.supportsThinking ?? false,
         tool_call: mi.supportsAgent ?? true,
         temperature: false,
         limit: {
-            context: mi.maxContext ?? 200000,
+            context,
             output: 4096,
         },
     };
-    const variants = modelInfoVariants(mi);
-    if (variants)
-        config.variants = variants;
+    const variantConfig = modelInfoVariants(mi, variants);
+    if (variantConfig)
+        config.variants = variantConfig;
+    if (contextTier === "long") {
+        const defaultVariant = variants.find((v) => v.isDefaultMax) ?? variants[0];
+        if (defaultVariant) {
+            config.options = {
+                [CURSOR_WIRE_MODEL_ID_KEY]: mi.id,
+                [CURSOR_VARIANT_PARAMETERS_KEY]: defaultVariant.parameterValues.map((p) => ({ ...p })),
+            };
+        }
+    }
     return config;
 }
-function modelsToConfig(models) {
+export function modelsToConfig(models) {
     const ambiguous = thinkingSuffixBaseNames(models);
     const out = {};
+    const usedIds = new Set(models.map((m) => m.id));
     for (const m of models) {
-        out[m.id] = modelInfoToConfig(m, {
-            thinkingSuffix: !!m.supportsThinking && ambiguous.has(baseName(m)),
-        });
+        const thinkingSuffix = !!m.supportsThinking && ambiguous.has(baseName(m));
+        const baseVariants = variantsForTier(m, "base");
+        const longVariants = variantsForTier(m, "long");
+        if (baseVariants.length > 0 || longVariants.length === 0) {
+            out[m.id] = modelInfoToConfig(m, { thinkingSuffix, contextTier: "base" });
+        }
+        if (longVariants.length === 0)
+            continue;
+        if (baseVariants.length === 0) {
+            out[m.id] = modelInfoToConfig(m, { thinkingSuffix, contextTier: "long" });
+            continue;
+        }
+        let longId = `${m.id}-1m`;
+        let suffix = 2;
+        while (usedIds.has(longId))
+            longId = `${m.id}-1m-${suffix++}`;
+        usedIds.add(longId);
+        out[longId] = modelInfoToConfig(m, { thinkingSuffix, contextTier: "long" });
     }
     return out;
 }
@@ -198,25 +283,27 @@ export async function CursorPlugin(input) {
     }
     async function loadModels() {
         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, { baseURL: apiBaseURL });
-                        return modelsToConfig(models);
-                    }
-                    catch {
-                        // discovery failed — leave the list empty
-                    }
+        if (cached?.models.length && isCacheFresh(cached)) {
+            return modelsToConfig(cached.models);
+        }
+        // Config runs before auth.loader and has no getAuth(); read the durable
+        // store (normally the same source getAuth() uses). Refresh missing, expired,
+        // or old-schema caches here so this process materializes the new model set.
+        const auth = await authFromStore();
+        if (auth) {
+            const accessToken = await resolveAccessToken(auth);
+            if (accessToken) {
+                try {
+                    const models = await discoverModels(accessToken, cacheDir, { baseURL: apiBaseURL });
+                    return modelsToConfig(models);
+                }
+                catch {
+                    // No usable cache and discovery failed — leave the list empty.
                 }
             }
-            return {};
         }
-        return modelsToConfig(cached.models);
+        // Preserve stale-on-failure/offline behavior for an existing cache.
+        return cached?.models.length ? modelsToConfig(cached.models) : {};
     }
     return {
         async config(cfg) {

package/dist/shared.d.ts

@@ -7,6 +7,8 @@ export declare const RUN_PATH = "/agent.v1.AgentService/Run";
 export declare const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
 export declare const SERVER_CONFIG_PATH = "/aiserver.v1.ServerConfigService/GetServerConfig";
 export declare const MODEL_CACHE_FILE = "cursor-models.json";
+/** Bumped when the on-disk model cache shape/semantics change (forces refetch). */
+export declare const MODEL_CACHE_SCHEMA_VERSION = 2;
 export declare const MODEL_CACHE_TTL_MS = 86400000;
 export declare const VERSION_CACHE_FILE = "cursor-client-version.json";
 export declare const CONTENT_TYPE_CONNECT_PROTO = "application/connect+proto";

package/dist/shared.js

@@ -7,6 +7,8 @@ export const RUN_PATH = "/agent.v1.AgentService/Run";
 export const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
 export const SERVER_CONFIG_PATH = "/aiserver.v1.ServerConfigService/GetServerConfig";
 export const MODEL_CACHE_FILE = "cursor-models.json";
+/** Bumped when the on-disk model cache shape/semantics change (forces refetch). */
+export const MODEL_CACHE_SCHEMA_VERSION = 2;
 export const MODEL_CACHE_TTL_MS = 86_400_000;
 export const VERSION_CACHE_FILE = "cursor-client-version.json";
 export const CONTENT_TYPE_CONNECT_PROTO = "application/connect+proto";

package/dist/transport/connect.js

@@ -36,7 +36,17 @@ export async function unaryAvailableModels(token, options = {}) {
             "content-type": "application/json",
             accept: "application/json",
         },
-        body: "{}",
+        // AvailableModelsRequest flags (proto aiserver.v1). The IDE sets these
+        // (modelConfigService.js useModelParameters, entry.js includeLongContextModels).
+        // useModelParameters + useCloudAgentEffortModes return parameterized
+        // variants (effort/context/fast). includeLongContextModels may populate
+        // context_token_limit fields; when those stay empty we still derive limits
+        // from each variant's `context` param in mapAvailableModelsResponse.
+        body: JSON.stringify({
+            includeLongContextModels: true,
+            useModelParameters: true,
+            useCloudAgentEffortModes: true,
+        }),
     });
     if (!res.ok) {
         const text = await res.text().catch(() => "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -62,4 +62,4 @@
     "@types/node": "^22.15.3",
     "typescript": "^5.8.3"
   }
-}
+}