cursor-opencode-provider 0.1.4 → 0.2.1

package/README.md

@@ -18,7 +18,7 @@ OpenCode driving a Cursor-routed Grok model through this provider:
 - **Authentication** — browser OAuth (PKCE), or API key from [cursor.com/settings](https://cursor.com/settings)
 - **Model discovery** — fetches available models from Cursor's API and caches them locally
 - **Streaming** — bidirectional Connect-RPC stream for agent runs
-- **Tool calls** — maps Cursor exec-server messages to AI SDK tool-call parts
+- **Tool calls** — maps Cursor exec-server messages to AI SDK tool-call parts; strips OpenCode's `read` XML envelope (`<path>`/`<content>` + `N:` prefixes) before returning content to Cursor so the model cannot echo the wrapper into writes
 - **Thinking / reasoning** — surfaces extended-thinking deltas where the model supports it
 
 ## Requirements
@@ -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.4"`.
+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
@@ -181,6 +206,7 @@ OpenCode
 | `src/index.ts` | `createCursor` factory; default export is `CursorPlugin` |
 | `src/language-model.ts` | AI SDK `LanguageModelV3` adapter (`doStream`, `doGenerate`) |
 | `src/session.ts` | Held-open agent Run session and pending exec correlation |
+| `src/debug.ts` | Opt-in wire-level debug logging (`CURSOR_PROVIDER_DEBUG`) |
 | `src/auth.ts` | PKCE OAuth, API key exchange, JWT refresh |
 | `src/models.ts` | `AvailableModels` fetch and `cursor-models.json` cache |
 | `src/agent-url.ts` | `GetServerConfig` fetch + in-process memo (region-specific Run host) |

package/dist/agent-url.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { fetchAgentUrl, trace } from "./transport/connect.js";
+import { fetchAgentUrl } from "./transport/connect.js";
+import { trace } from "./debug.js";
 import { CURSOR_API_HOST } from "./shared.js";
 const DEFAULT_API_BASE = `https://${CURSOR_API_HOST}`;
 // In-process memo of the region-specific Run stream origin (agentnUrl). Resolved

package/dist/debug.d.ts

@@ -0,0 +1 @@
+export declare function trace(msg: string): void;

package/dist/debug.js

@@ -0,0 +1,22 @@
+import fs from "node:fs";
+// Wire-level diagnostics. Opt in with CURSOR_PROVIDER_DEBUG=1 (or "true").
+// Writes to CURSOR_PROVIDER_DEBUG_FILE (default /tmp/cursor-provider-debug.log).
+// Truncated once per process. Tokens / checksums should be redacted by callers.
+const DEBUG_ENABLED = process.env.CURSOR_PROVIDER_DEBUG === "1" ||
+    process.env.CURSOR_PROVIDER_DEBUG === "true";
+const DEBUG_FILE = process.env.CURSOR_PROVIDER_DEBUG_FILE || "/tmp/cursor-provider-debug.log";
+let _traceInitialized = false;
+export function trace(msg) {
+    if (!DEBUG_ENABLED)
+        return;
+    try {
+        if (!_traceInitialized) {
+            _traceInitialized = true;
+            fs.writeFileSync(DEBUG_FILE, `--- cursor-provider debug (pid ${process.pid}) ${new Date().toISOString()} ---\n`);
+        }
+        fs.appendFileSync(DEBUG_FILE, `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch {
+        /* ignore */
+    }
+}

package/dist/language-model.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { createHash } from "node:crypto";
-import { bidiRunStream, normalizeAgentRunOrigin, trace } from "./transport/connect.js";
+import { bidiRunStream, normalizeAgentRunOrigin } from "./transport/connect.js";
+import { trace } from "./debug.js";
 import { buildRunRequest, buildHeartbeat } from "./protocol/request.js";
 import { decodeFramePayload } from "./protocol/framing.js";
 import { decodeMessage } from "./protocol/messages.js";
@@ -9,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";
@@ -78,6 +79,7 @@ async function doStreamImpl(modelId, options, callOptions) {
                     resultField: pending.resultField,
                     output: r.output,
                     error: r.error,
+                    toolName: pending.toolName ?? r.toolName,
                 })) {
                     session.stream.write(frame);
                 }
@@ -182,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.
@@ -206,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,
@@ -225,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} ` +
@@ -575,6 +591,7 @@ async function pump(session, controller, ids, abortSignal) {
                                     resultField: parsed.resultField,
                                     output: "",
                                     error: reason,
+                                    toolName: parsed.toolName,
                                 })) {
                                     session.stream.write(frame);
                                 }
@@ -586,7 +603,7 @@ async function pump(session, controller, ids, abortSignal) {
                         }
                         const tc = buildToolCallPart(parsed, session.sessionId);
                         // Keep the stream open; the result arrives on the next doStream call.
-                        sessionManager.registerPending(parsed.id, session, parsed.resultField);
+                        sessionManager.registerPending(parsed.id, session, parsed.resultField, parsed.toolName);
                         // tc.input is already a JSON string (LanguageModelV3ToolCall.input).
                         trace(`exec: EMITTED tool-call toolCallId=${tc.toolCallId} toolName=${tc.toolName} inputLen=${tc.input.length}`);
                         // Close open text/reasoning spans before tool-call (required by AI SDK V3).

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/protocol/tools.d.ts

@@ -53,6 +53,12 @@ export type ToolResultInput = {
     output: string;
     error?: string;
     executionTimeMs?: number;
+    /**
+     * Resolved opencode tool name (read/write/grep/…). Gates read-envelope
+     * unwrapping on the mcp_result path so non-read MCP output is never
+     * rewritten. read_result is always a read, so it unwraps regardless.
+     */
+    toolName?: string;
 };
 /**
  * Build one or more ExecClientMessage frames for a tool result.
@@ -64,12 +70,33 @@ export type ToolResultInput = {
 export declare function buildExecClientMessages(input: ToolResultInput): Uint8Array[];
 /** ACM #5 exec_client_control_message { stream_close { id } }. */
 export declare function buildExecStreamClose(execId: number): Uint8Array;
+/**
+ * Strip opencode's `read` envelope, leaving raw file content.
+ *
+ * opencode's read tool (opencode `tool/read.ts`) wraps content in an XML-ish
+ * envelope its own models are trained on, but Cursor's are not:
+ *   <path>{abs}</path>\n<type>file</type>\n<content>\n{N}: {line}\n…\n\n{footer}\n</content>
+ * Forwarding that envelope verbatim made Cursor's model treat the wrapper as
+ * literal file content and write `<path>`/`<content>` tags + `N:` line prefixes
+ * back into files (silent corruption — the write still reports success; seen
+ * across 8+ sessions, e.g. language-model.ts rewritten starting with
+ * `<path>…</path>\n<type>file</type>\n<content>\n1: import fs…`).
+ *
+ * Returns the raw file body (line numbers + footer + `<system-reminder>` dropped).
+ *
+ * Deliberately exception-safe: if the expected envelope is absent — non-read
+ * output, already-raw text, or a future opencode format change — it returns the
+ * input unchanged, so a result is never broken and we never throw mid-turn.
+ * Callers must still gate `mcp_result` on `toolName === "read"`; this helper
+ * alone is not a tool-identity check.
+ */
+export declare function unwrapReadOutput(output: string): string;
 /**
  * Map OpenCode tool text into the agent.v1 result oneof for each exec variant.
  * OpenCode returns free-form text; we wrap it in the minimal success shape the
  * server accepts (verified against agent.v1 wire captures).
  */
-export declare function buildTypedExecResult(resultField: string, output: string, error?: string): Record<string, unknown>;
+export declare function buildTypedExecResult(resultField: string, output: string, error?: string, toolName?: string): Record<string, unknown>;
 export declare function buildToolCallPart(execMsg: ParsedExecRequest, sessionId: string): {
     toolCallId: string;
     toolName: string;

package/dist/protocol/tools.js

@@ -1,5 +1,6 @@
 import { encodeMessage } from "./messages.js";
 import { encodeJsonAsValue, decodeStructEntriesToJson, readAllFields } from "./struct.js";
+import { trace } from "../debug.js";
 // Exec variant field number whose reply is the server-initiated request_context
 // probe (ExecServerMessage #10 → ExecClientMessage #10). request/result share a
 // field number for every exec variant, so this is also the result field.
@@ -394,7 +395,7 @@ export function buildExecClientMessages(input) {
             id: input.execId,
             local_execution_time_ms: input.executionTimeMs ?? 0,
         };
-        clientMsg[resultField] = buildTypedExecResult(resultField, input.output, input.error);
+        clientMsg[resultField] = buildTypedExecResult(resultField, input.output, input.error, input.toolName);
         frames.push(encodeMessage("AgentClientMessage", {
             exec_client_message: clientMsg,
         }));
@@ -411,21 +412,90 @@ export function buildExecStreamClose(execId) {
         },
     });
 }
+/**
+ * Strip opencode's `read` envelope, leaving raw file content.
+ *
+ * opencode's read tool (opencode `tool/read.ts`) wraps content in an XML-ish
+ * envelope its own models are trained on, but Cursor's are not:
+ *   <path>{abs}</path>\n<type>file</type>\n<content>\n{N}: {line}\n…\n\n{footer}\n</content>
+ * Forwarding that envelope verbatim made Cursor's model treat the wrapper as
+ * literal file content and write `<path>`/`<content>` tags + `N:` line prefixes
+ * back into files (silent corruption — the write still reports success; seen
+ * across 8+ sessions, e.g. language-model.ts rewritten starting with
+ * `<path>…</path>\n<type>file</type>\n<content>\n1: import fs…`).
+ *
+ * Returns the raw file body (line numbers + footer + `<system-reminder>` dropped).
+ *
+ * Deliberately exception-safe: if the expected envelope is absent — non-read
+ * output, already-raw text, or a future opencode format change — it returns the
+ * input unchanged, so a result is never broken and we never throw mid-turn.
+ * Callers must still gate `mcp_result` on `toolName === "read"`; this helper
+ * alone is not a tool-identity check.
+ */
+export function unwrapReadOutput(output) {
+    if (typeof output !== "string" || output.length === 0)
+        return output;
+    // Require the full opencode read-envelope skeleton *before* `<content>`
+    // (read.ts opens with <path>…</path>, <type>file</type>, <content>) so a
+    // stray "<content>" later in tool chatter can't trigger unwrapping just
+    // because path/type tags appear elsewhere in the payload.
+    const contentHeaderIdx = output.indexOf("<content>");
+    if (contentHeaderIdx === -1)
+        return output;
+    const header = output.slice(0, contentHeaderIdx);
+    const hasSkeleton = header.indexOf("<path>") !== -1 &&
+        header.indexOf("<type>file</type>") !== -1;
+    if (!hasSkeleton) {
+        // Saw "<content>" but not the read skeleton ahead of it — almost certainly
+        // a non-read payload, or an opencode format drift. Surface it so drift
+        // can't silently resurrect the wrapper-corruption bug, but still fail
+        // safe (no mutate).
+        trace("unwrapReadOutput: <content> present without leading <path>/<type>file> skeleton — leaving output unchanged (possible non-read payload or opencode read format drift)");
+        return output;
+    }
+    // Body starts right after "<content>\n". opencode emits one numbered line per
+    // file line ("N: <line>"), then a blank, a "(…)" footer, and a standalone
+    // "</content>". The body is a *contiguous run* of /^N: / lines — so we stop at
+    // the first non-numbered line. Critically we do NOT search for a closing
+    // "</content>" substring: a file line that literally contains "</content>"
+    // is rendered as "N: </content>" (a body line), and a raw indexOf would
+    // truncate the read there.
+    let rest = output.slice(contentHeaderIdx + "<content>".length);
+    if (rest.startsWith("\n"))
+        rest = rest.slice(1);
+    const raw = [];
+    for (const line of rest.split("\n")) {
+        const m = /^(\d+):[ \t]?(.*)$/.exec(line);
+        if (!m)
+            break; // blank / "(footer)" / "</content>" → end of body run
+        // Strip only the leading "N: " prefix; a line that itself begins with
+        // digits+colon keeps its content (we remove just the first match). Blank
+        // file lines render as "N: " and are preserved (capture group is "").
+        raw.push(m[2]);
+    }
+    // Envelope confirmed but no numbered body → empty file. Return "" rather
+    // than the envelope (the envelope is exactly what Cursor echoes into writes).
+    return raw.join("\n");
+}
 /**
  * Map OpenCode tool text into the agent.v1 result oneof for each exec variant.
  * OpenCode returns free-form text; we wrap it in the minimal success shape the
  * server accepts (verified against agent.v1 wire captures).
  */
-export function buildTypedExecResult(resultField, output, error) {
+export function buildTypedExecResult(resultField, output, error, toolName) {
     switch (resultField) {
         case "read_result":
             if (error)
                 return { error: { path: "", error } };
+            // Strip opencode's <path>/<content> envelope so Cursor's model receives
+            // raw file content and can't echo the wrapper into subsequent writes.
+            // reads route here only for native read_args; most arrive via mcp_result.
+            const content = unwrapReadOutput(output);
             return {
                 success: {
                     path: extractPathTag(output) ?? "",
-                    content: output,
-                    total_lines: countLines(output),
+                    content,
+                    total_lines: countLines(content),
                 },
             };
         case "grep_result": {
@@ -492,9 +562,15 @@ export function buildTypedExecResult(resultField, output, error) {
         case "mcp_result":
             if (error)
                 return { error: { error } };
+            // opencode built-ins (read/write/grep/…) are advertised as MCP tools, so
+            // a read call returns through mcp_result. Scope the unwrap to toolName
+            // "read" so a non-read MCP tool whose output merely contains a
+            // "<content>"-like block is never rewritten.
             return {
                 success: {
-                    content: [{ text: { text: output } }],
+                    content: [
+                        { text: { text: toolName === "read" ? unwrapReadOutput(output) : output } },
+                    ],
                     is_error: false,
                 },
             };

package/dist/session.d.ts

@@ -14,6 +14,11 @@ export type Frame = {
 export type PendingExec = {
     /** ExecClientMessage result field to reply with (matches the request variant). */
     resultField: string;
+    /**
+     * Resolved opencode tool name (read/write/grep/…). Used on continuation so
+     * mcp_result can unwrap read envelopes even if the prompt omits toolName.
+     */
+    toolName?: string;
 };
 export type CursorSession = {
     /**
@@ -58,7 +63,7 @@ export declare class SessionManager {
     constructor(idleTimeoutMs?: number);
     touch(session: CursorSession): void;
     /** Register that `session` is awaiting a result for `execId`. */
-    registerPending(execId: number, session: CursorSession, resultField: string): void;
+    registerPending(execId: number, session: CursorSession, resultField: string, toolName?: string): void;
     /** The pending exec info for an id on a specific session, if still awaiting it. */
     pendingFor(sessionId: string, execId: number): PendingExec | undefined;
     /** Find the live session awaiting one of the given exec ids. */

package/dist/session.js

@@ -1,4 +1,4 @@
-import { trace } from "./transport/connect.js";
+import { trace } from "./debug.js";
 export class SessionManager {
     // Composite key `${sessionId}:${execId}` → owning session. Composite keying
     // means two Run streams that both register an execId of 1 (Cursor resets
@@ -12,8 +12,8 @@ export class SessionManager {
         session.expiresAt = Date.now() + this.idleTimeoutMs;
     }
     /** Register that `session` is awaiting a result for `execId`. */
-    registerPending(execId, session, resultField) {
-        session.pending.set(execId, { resultField });
+    registerPending(execId, session, resultField, toolName) {
+        session.pending.set(execId, { resultField, toolName });
         this.byExecId.set(this.key(session.sessionId, execId), session);
         this.touch(session);
     }

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

@@ -1,4 +1,3 @@
-export declare function trace(msg: string): void;
 export declare function buildBaseHeaders(token: string, clientVersion: string, extra?: Record<string, string>): Record<string, string>;
 export declare function unaryAvailableModels(token: string, options?: {
     apiBaseURL?: string;

package/dist/transport/connect.js

@@ -3,32 +3,12 @@ import { encodeFrame, streamFrames } from "../protocol/framing.js";
 import { createCursorChecksumHeader } from "../protocol/checksum.js";
 import { getDeviceIds } from "../protocol/device-id.js";
 import { resolveClientVersion } from "../protocol/client-version.js";
+import { trace } from "../debug.js";
 import http2 from "node:http2";
-import fs from "node:fs";
 const API_BASE = `https://${CURSOR_API_HOST}`;
 function resolveApiBaseURL(options) {
     return new URL(options.apiBaseURL ?? options.baseURL ?? API_BASE).origin;
 }
-// Wire-level diagnostics. Opt in with CURSOR_PROVIDER_DEBUG=1 (or "true").
-// Writes to CURSOR_PROVIDER_DEBUG_FILE (default /tmp/cursor-provider-debug.log).
-// Truncated once per process. Captures h2 response status, parsed frames, and
-// stream errors. Tokens / checksums are redacted in header dumps.
-const DEBUG_ENABLED = process.env.CURSOR_PROVIDER_DEBUG === "1" ||
-    process.env.CURSOR_PROVIDER_DEBUG === "true";
-const DEBUG_FILE = process.env.CURSOR_PROVIDER_DEBUG_FILE || "/tmp/cursor-provider-debug.log";
-let _traceInitialized = false;
-export function trace(msg) {
-    if (!DEBUG_ENABLED)
-        return;
-    try {
-        if (!_traceInitialized) {
-            _traceInitialized = true;
-            fs.writeFileSync(DEBUG_FILE, `--- cursor-provider debug (pid ${process.pid}) ${new Date().toISOString()} ---\n`);
-        }
-        fs.appendFileSync(DEBUG_FILE, `[${new Date().toISOString()}] ${msg}\n`);
-    }
-    catch { /* ignore */ }
-}
 trace("connect.ts module loaded");
 export function buildBaseHeaders(token, clientVersion, extra) {
     const { machineId, macMachineId } = getDeviceIds();
@@ -56,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.4",
+  "version": "0.2.1",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -54,10 +54,10 @@
     "protobufjs": "^7.4.0"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": "~1.17.13"
+    "@opencode-ai/plugin": "^1.17.13"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "~1.17.13",
+    "@opencode-ai/plugin": "^1.17.13",
     "@tsconfig/node22": "^22.0.1",
     "@types/node": "^22.15.3",
     "typescript": "^5.8.3"