cursor-opencode-provider 0.1.5 → 0.2.2

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 { CURSOR_COMPACTION_OPTION, 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,71 @@ 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);
+    // OpenCode's overflow/compaction/UI use limit.context; generation and
+    // thinking budgets use limit.output. models.dev 1M peers advertise
+    // 64k–128k output — a tiny cap makes long-context sessions feel broken
+    // even when the 1M input window is correct.
+    const output = contextTier === "long" ? 128_000 : 32_000;
     const config = {
         name,
         reasoning: mi.supportsThinking ?? false,
         tool_call: mi.supportsAgent ?? true,
         temperature: false,
         limit: {
-            context: mi.maxContext ?? 200000,
-            output: 4096,
+            context,
+            output,
         },
     };
-    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,27 +288,39 @@ 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 "chat.params"(hookInput, output) {
+            if (hookInput.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            // OpenCode's compaction pipeline invokes the LLM with agent="compaction".
+            // Carry that stable runtime fact into LanguageModelV3 providerOptions so
+            // the provider never has to guess from an empty tool list.
+            if (hookInput.agent === "compaction") {
+                output.options[CURSOR_COMPACTION_OPTION] = true;
+            }
+        },
         async config(cfg) {
             cfg.provider ??= {};
             const models = await loadModels();

package/dist/protocol/blob-store.d.ts

@@ -10,6 +10,8 @@
 export declare function setConversationBlob(conversationId: string, blobId: Uint8Array, blobData: Uint8Array): string;
 export declare function getConversationBlob(conversationId: string, blobId: Uint8Array): Uint8Array | undefined;
 export declare function conversationBlobCount(conversationId: string): number;
+/** Drop all blobs for a conversation (compaction conversation reset). */
+export declare function clearConversationBlobs(conversationId: string): void;
 /** SHA-256 content hashes are 32 non-text bytes — never echo those as content. */
 export declare function isBlobIdHash(blobId: Uint8Array): boolean;
 export declare function resetConversationBlobsForTests(): void;

package/dist/protocol/blob-store.js

@@ -34,6 +34,10 @@ export function getConversationBlob(conversationId, blobId) {
 export function conversationBlobCount(conversationId) {
     return byConversation.get(conversationId)?.size ?? 0;
 }
+/** Drop all blobs for a conversation (compaction conversation reset). */
+export function clearConversationBlobs(conversationId) {
+    byConversation.delete(conversationId);
+}
 /** SHA-256 content hashes are 32 non-text bytes — never echo those as content. */
 export function isBlobIdHash(blobId) {
     if (blobId.length !== 32)

package/dist/protocol/conversation-bind.d.ts

@@ -0,0 +1,18 @@
+export declare const MAX_ACTIVE_CONVERSATION_BINDINGS = 256;
+export declare function resetConversationBindingsForTests(): void;
+/** Deterministic UUID (version-4 shape) from an arbitrary session key. */
+export declare function sessionIdToUuid(sessionId: string): string;
+/** Current Cursor conversation_id for an OpenCode session key, creating the default binding if needed. */
+export declare function peekConversationId(sessionKey: string): string;
+/**
+ * Resolve the Cursor conversation_id for this OpenCode session.
+ * When `reset` is true (compaction/summary), discard prior Cursor state and
+ * mint a new id so TurnEnded cache_read cannot keep overflowing OpenCode.
+ */
+export declare function bindConversationId(sessionKey: string | undefined, opts?: {
+    reset?: boolean;
+}): {
+    conversationId: string;
+    reset: boolean;
+    previousId?: string;
+};

package/dist/protocol/conversation-bind.js

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { clearCheckpoint } from "./checkpoint.js";
+import { clearConversationBlobs } from "./blob-store.js";
+/**
+ * OpenCode session key → active Cursor conversation_id.
+ *
+ * Normally the binding is the deterministic UUID from the OpenCode session id
+ * (CLI-shaped sticky conversation). Compaction/summary turns mint a fresh id
+ * and drop the prior checkpoint + blobs so Cursor no longer bills the old
+ * cached conversation against OpenCode's newly compacted prompt.
+ */
+const activeBySession = new Map();
+export const MAX_ACTIVE_CONVERSATION_BINDINGS = 256;
+function rememberConversation(sessionKey, conversationId) {
+    // Map insertion order is the LRU order. Refresh existing sessions on use.
+    activeBySession.delete(sessionKey);
+    activeBySession.set(sessionKey, conversationId);
+    while (activeBySession.size > MAX_ACTIVE_CONVERSATION_BINDINGS) {
+        const oldest = activeBySession.entries().next().value;
+        if (!oldest)
+            break;
+        activeBySession.delete(oldest[0]);
+        clearCheckpoint(oldest[1]);
+        clearConversationBlobs(oldest[1]);
+    }
+}
+export function resetConversationBindingsForTests() {
+    activeBySession.clear();
+}
+/** Deterministic UUID (version-4 shape) from an arbitrary session key. */
+export function sessionIdToUuid(sessionId) {
+    const hash = createHash("sha256").update(`cursor-opencode-provider:conv:${sessionId}`).digest();
+    const bytes = Buffer.from(hash.subarray(0, 16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+/** Current Cursor conversation_id for an OpenCode session key, creating the default binding if needed. */
+export function peekConversationId(sessionKey) {
+    let id = activeBySession.get(sessionKey);
+    if (!id) {
+        id = sessionIdToUuid(sessionKey);
+    }
+    rememberConversation(sessionKey, id);
+    return id;
+}
+/**
+ * Resolve the Cursor conversation_id for this OpenCode session.
+ * When `reset` is true (compaction/summary), discard prior Cursor state and
+ * mint a new id so TurnEnded cache_read cannot keep overflowing OpenCode.
+ */
+export function bindConversationId(sessionKey, opts) {
+    if (!sessionKey) {
+        return { conversationId: crypto.randomUUID(), reset: !!opts?.reset };
+    }
+    if (opts?.reset) {
+        const previousId = activeBySession.get(sessionKey) ?? sessionIdToUuid(sessionKey);
+        clearCheckpoint(previousId);
+        clearConversationBlobs(previousId);
+        const conversationId = crypto.randomUUID();
+        rememberConversation(sessionKey, conversationId);
+        return { conversationId, reset: true, previousId };
+    }
+    return { conversationId: peekConversationId(sessionKey), reset: false };
+}