cursor-opencode-provider 0.8.1 → 0.8.3

package/dist/lost-request.d.ts

@@ -0,0 +1,39 @@
+export type LostRequest = {
+    conversationId: string;
+    checkpointKey: string;
+    /** Everything Cursor has not checkpointed, as the last attempt sent it. */
+    text: string;
+    /** That attempt's own live text, before anything was prepended. */
+    latest: string;
+};
+export declare function checkpointKey(bytes: Uint8Array | undefined): string;
+/**
+ * Prepend a user message whose Run never received a newer checkpoint.
+ * A history rebuild already contains it, so that path drops the record.
+ * A retry is the previous attempt's live text again: it sends what that
+ * attempt sent. A host that sends the same note before every attempt must not
+ * pile it up. Any other text is a new request and is appended, even when it
+ * repeats an older one (red, blue, then red again).
+ */
+export declare function carryLostRequest(input: {
+    sessionKey: string;
+    conversationId: string;
+    checkpoint: Uint8Array | undefined;
+    text: string;
+    rebuildFromHistory: boolean;
+}): string;
+/** `text` is what this turn sends; `latest` is its own live text (defaults to `text`). */
+export declare function rememberLostRequest(input: {
+    sessionKey: string;
+    conversationId: string;
+    checkpoint: Uint8Array | undefined;
+    text: string;
+    latest?: string;
+}): void;
+/** A checkpoint other than the one this turn was sent on means Cursor kept the turn. */
+export declare function noteCheckpoint(sessionKey: string | undefined, bytes: Uint8Array): void;
+export declare function hasLostRequest(sessionKey: string | undefined): boolean;
+export declare function dropLostRequest(sessionKey: string | undefined): void;
+export declare function serializeLostRequest(sessionKey: string | undefined): string | undefined;
+export declare function restoreLostRequest(sessionKey: string, raw: string | undefined): void;
+export declare function resetLostRequestsForTests(): void;

package/dist/lost-request.js

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+import { processShared } from "./process-shared.js";
+const MAX_RECORDS = 1_024;
+const records = () => processShared("lost-request.v2", () => new Map());
+export function checkpointKey(bytes) {
+    if (!bytes?.length)
+        return "none";
+    return createHash("sha256").update(bytes).digest("hex");
+}
+/**
+ * Prepend a user message whose Run never received a newer checkpoint.
+ * A history rebuild already contains it, so that path drops the record.
+ * A retry is the previous attempt's live text again: it sends what that
+ * attempt sent. A host that sends the same note before every attempt must not
+ * pile it up. Any other text is a new request and is appended, even when it
+ * repeats an older one (red, blue, then red again).
+ */
+export function carryLostRequest(input) {
+    const map = records();
+    const record = map.get(input.sessionKey);
+    if (!record)
+        return input.text;
+    const key = checkpointKey(input.checkpoint);
+    if (input.rebuildFromHistory
+        || record.conversationId !== input.conversationId
+        || record.checkpointKey !== key) {
+        map.delete(input.sessionKey);
+        return input.text;
+    }
+    if (input.text === record.latest)
+        return record.text;
+    // The host already resends the lost text ahead of this one (OpenCode 1.x
+    // merges user messages left without a reply into one live turn).
+    if (input.text === record.text || input.text.startsWith(`${record.text}\n\n`))
+        return input.text;
+    map.delete(input.sessionKey);
+    return `${record.text}\n\n${input.text}`;
+}
+/** `text` is what this turn sends; `latest` is its own live text (defaults to `text`). */
+export function rememberLostRequest(input) {
+    if (!input.sessionKey || !input.text || input.text === ".")
+        return;
+    setRecord(input.sessionKey, {
+        conversationId: input.conversationId,
+        checkpointKey: checkpointKey(input.checkpoint),
+        text: input.text,
+        latest: input.latest ?? input.text,
+    });
+}
+/** A session that never sends another turn must not keep its record forever. */
+function setRecord(sessionKey, record) {
+    const map = records();
+    map.delete(sessionKey);
+    map.set(sessionKey, record);
+    while (map.size > MAX_RECORDS) {
+        const oldest = map.keys().next().value;
+        if (oldest === undefined)
+            break;
+        map.delete(oldest);
+    }
+}
+/** A checkpoint other than the one this turn was sent on means Cursor kept the turn. */
+export function noteCheckpoint(sessionKey, bytes) {
+    if (!sessionKey)
+        return;
+    const map = records();
+    const record = map.get(sessionKey);
+    if (!record)
+        return;
+    if (checkpointKey(bytes) !== record.checkpointKey)
+        map.delete(sessionKey);
+}
+export function hasLostRequest(sessionKey) {
+    return !!sessionKey && records().has(sessionKey);
+}
+export function dropLostRequest(sessionKey) {
+    if (sessionKey)
+        records().delete(sessionKey);
+}
+export function serializeLostRequest(sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    const record = records().get(sessionKey);
+    return record ? JSON.stringify(record) : undefined;
+}
+export function restoreLostRequest(sessionKey, raw) {
+    if (!raw || records().has(sessionKey))
+        return;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    if (typeof parsed.conversationId !== "string"
+        || typeof parsed.checkpointKey !== "string"
+        || typeof parsed.text !== "string"
+        || parsed.text.length === 0
+        || (parsed.latest !== undefined && typeof parsed.latest !== "string"))
+        return;
+    setRecord(sessionKey, {
+        conversationId: parsed.conversationId,
+        checkpointKey: parsed.checkpointKey,
+        text: parsed.text,
+        latest: parsed.latest ?? parsed.text,
+    });
+}
+export function resetLostRequestsForTests() {
+    records().clear();
+}

package/dist/model-config.d.ts

@@ -1,4 +1,5 @@
 import { type ModelInfo, type ModelVariant } from "./models.js";
+type ContextTier = "base" | "long" | number;
 /**
  * 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
@@ -19,8 +20,9 @@ export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string
 export declare function cursorModelFamily(id: string): string | undefined;
 export declare function modelInfoToConfig(mi: ModelInfo, options?: {
     thinkingSuffix?: boolean;
-    contextTier?: "base" | "long";
+    contextTier?: ContextTier;
     variants?: ModelVariant[];
     fast?: boolean;
 }): Record<string, any>;
 export declare function modelsToConfig(models: ModelInfo[]): Record<string, any>;
+export {};

package/dist/model-config.js

@@ -1,4 +1,4 @@
-import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, parseCursorContextLimit, } from "./models.js";
+import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, findDefaultVariant, parseCursorContextLimit, } from "./models.js";
 import { applyCursorModelCost, hasCursorFastPricing } from "./pricing.js";
 import { getDocumentedCursorModelContext, resolveCursorModelSupportsImages, } from "./model-metadata.js";
 /**
@@ -112,8 +112,23 @@ function isLongContextVariant(v) {
 function isFastVariant(v) {
     return v.parameterValues.some((p) => p.id === "fast" && p.value === "true");
 }
+function variantContext(v) {
+    return parseCursorContextLimit(v.parameterValues.find((p) => p.id === "context")?.value);
+}
+function isSeparateContext(mi, v) {
+    const context = variantContext(v);
+    return isLongContextVariant(v) ||
+        (v.isMaxMode === true && context !== undefined && context !== mi.maxContext);
+}
+function contextSuffix(context) {
+    return context % 1_000_000 === 0 ? `${context / 1_000_000}m` : `${context / 1_000}k`;
+}
 function variantsForTier(mi, tier) {
-    return mi.variants.filter((v) => isLongContextVariant(v) === (tier === "long"));
+    return mi.variants.filter((v) => tier === "base"
+        ? !isSeparateContext(mi, v)
+        : tier === "long"
+            ? isLongContextVariant(v)
+            : isSeparateContext(mi, v) && variantContext(v) === tier);
 }
 /**
  * Display names shared by both a thinking and a non-thinking model. A thinking
@@ -171,6 +186,8 @@ export function modelInfoToConfig(mi, options = {}) {
         name += " Fast";
     if (contextTier === "long")
         name += " 1M";
+    if (typeof contextTier === "number")
+        name += ` ${contextSuffix(contextTier).toUpperCase()}`;
     // 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.
@@ -179,9 +196,12 @@ export function modelInfoToConfig(mi, options = {}) {
     // live checkpoints report 256k for the base tier — the previous 200k
     // fallback made the host context meter disagree with Cursor.
     const fallbackContext = mi.id === "default" ? 256_000 : 200_000;
-    const context = contextTier === "long"
-        ? (mi.maxContextForMaxMode ?? documentedContext?.maxContextForMaxMode ?? 1_000_000)
-        : (mi.maxContext ?? documentedContext?.maxContext ?? fallbackContext);
+    const context = typeof contextTier === "number"
+        ? contextTier
+        : contextTier === "long"
+            ? (variants.some(isLongContextVariant) ? 1_000_000
+                : (mi.maxContextForMaxMode ?? documentedContext?.maxContextForMaxMode ?? 1_000_000))
+            : (mi.maxContext ?? documentedContext?.maxContext ?? fallbackContext);
     // 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
@@ -212,10 +232,8 @@ export function modelInfoToConfig(mi, options = {}) {
     const variantConfig = modelInfoVariants(mi, variants);
     if (variantConfig)
         config.variants = variantConfig;
-    if (contextTier === "long" || options.fast) {
-        const defaultVariant = contextTier === "long"
-            ? (variants.find((v) => v.isDefaultMax) ?? variants[0])
-            : (variants.find((v) => v.isDefaultNonMax) ?? variants[0]);
+    if (contextTier !== "base" || options.fast) {
+        const defaultVariant = findDefaultVariant(mi, variants, contextTier !== "base") ?? variants[0];
         if (defaultVariant) {
             config.options = {
                 [CURSOR_WIRE_MODEL_ID_KEY]: mi.id,
@@ -245,11 +263,9 @@ function uniqueCatalogId(usedIds, modelId, suffix) {
     }
     let n = 2;
     while (true) {
-        const candidate = suffix === "-fast"
-            ? `${modelId}-fast-${n}`
-            : suffix === "-1m-fast"
-                ? `${modelId}-1m-${n}-fast`
-                : `${modelId}-1m-${n}`;
+        const candidate = suffix !== "-fast" && suffix.endsWith("-fast")
+            ? `${modelId}${suffix.slice(0, -5)}-${n}-fast`
+            : `${modelId}${suffix}-${n}`;
         if (!usedIds.has(candidate)) {
             usedIds.add(candidate);
             return candidate;
@@ -265,13 +281,28 @@ export function modelsToConfig(models) {
         const thinkingSuffix = !!m.supportsThinking && ambiguous.has(baseName(m));
         const splitFast = hasCursorFastPricing(m.id);
         const groups = [];
-        for (const contextTier of ["base", "long"]) {
-            const suffixFor = (fast) => contextTier === "long" ? (fast ? "-1m-fast" : "-1m") : (fast ? "-fast" : "");
-            for (const group of speedGroups(variantsForTier(m, contextTier), splitFast)) {
+        const extraContexts = new Set(m.variants
+            .filter((v) => isSeparateContext(m, v) && !isLongContextVariant(v))
+            .map(variantContext)
+            .filter((context) => context !== undefined));
+        const tiers = ["base", "long", ...extraContexts];
+        for (const contextTier of tiers) {
+            const tierSuffix = contextTier === "base" ? ""
+                : contextTier === "long" ? "-1m" : `-${contextSuffix(contextTier)}`;
+            const suffixFor = (fast) => `${tierSuffix}${fast ? "-fast" : ""}`;
+            const tierVariants = new Set(variantsForTier(m, contextTier));
+            // Base/Fast ids and labels are persisted by the host. Keep their pre-split
+            // non-1M variants available while dedicated entries supply accurate limits.
+            const advertised = contextTier === "base"
+                ? m.variants.filter((variant) => !isLongContextVariant(variant))
+                : [...tierVariants];
+            for (const group of speedGroups(advertised, splitFast)) {
+                const tierGroup = group.variants.filter((variant) => tierVariants.has(variant));
                 groups.push({
                     contextTier,
                     fast: group.fast,
-                    variants: group.variants,
+                    variants: tierGroup.length > 0 ? tierGroup : group.variants,
+                    advertisedVariants: group.variants,
                     suffix: suffixFor(group.fast),
                 });
             }
@@ -293,17 +324,7 @@ export function modelsToConfig(models) {
                 variants: group.variants,
                 fast: group.fast,
             });
-            if (catalogId !== m.id && !config.options) {
-                const defaultVariant = (group.contextTier === "long"
-                    ? group.variants.find((v) => v.isDefaultMax)
-                    : group.variants.find((v) => v.isDefaultNonMax)) ?? group.variants[0];
-                if (defaultVariant) {
-                    config.options = {
-                        [CURSOR_WIRE_MODEL_ID_KEY]: m.id,
-                        [CURSOR_VARIANT_PARAMETERS_KEY]: defaultVariant.parameterValues.map((p) => ({ ...p })),
-                    };
-                }
-            }
+            config.variants = modelInfoVariants(m, group.advertisedVariants);
             out[catalogId] = applyCursorModelCost(pricingId, config);
         }
     }

package/dist/models.d.ts

@@ -12,6 +12,11 @@ export type ModelVariant = {
     displayName: string;
     isDefaultNonMax: boolean;
     isDefaultMax: boolean;
+    /**
+     * Cursor's `AvailableModelVariant.is_max_mode`: this tuple runs only with
+     * request-level max mode. Absent when discovery omits the marker.
+     */
+    isMaxMode?: boolean;
 };
 export type ModelInfo = {
     id: string;
@@ -24,6 +29,11 @@ export type ModelInfo = {
     /** Context window when max-mode is on (proto field 16). */
     maxContextForMaxMode?: number;
     supportsMaxMode?: boolean;
+    /**
+     * `AvailableModel.supports_non_max_mode`; `false` means every variant runs
+     * in max mode. Absent when discovery omits it.
+     */
+    supportsNonMaxMode?: boolean;
     variants: ModelVariant[];
 };
 export type ModelCache = {
@@ -45,17 +55,30 @@ export declare function normalizeModelCache(value: unknown): ModelCache | null;
  */
 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. */
+/**
+ * True when resolved params select the long-context (1m) tier. Fallback for
+ * variants without Cursor's `isMaxMode` marker.
+ */
 export declare function paramsImplyMaxMode(params: ModelParameterValue[]): boolean;
 /**
- * Resolve the request-level max_mode bit. An explicit variant pick owns the
- * context tier; otherwise a standalone maxMode hint may select max mode.
+ * Resolve the request-level max_mode bit. Like Cursor CLI, a cataloged variant
+ * requires max mode when Cursor marks it `isMaxMode` (Grok 4.7's 500k tier as
+ * well as 1m tiers) or the model does not support non-max mode. An explicit
+ * variant pick owns the context tier; otherwise a standalone maxMode hint may
+ * select max mode.
  */
 export declare function resolveVariantMaxMode(params: ModelParameterValue[], opts?: {
     picked?: ModelParameterValue[];
     maxMode?: boolean;
+    model?: ModelInfo;
 }): boolean;
 export declare function parseCursorContextLimit(value: unknown): number | undefined;
+/**
+ * Find Cursor's declared default within a catalog subset, retaining its effort:
+ * the declared variant, else its speed twin, else its twin in another context
+ * tier (a 500k entry when the declared max default is 1m).
+ */
+export declare function findDefaultVariant(model: ModelInfo, candidates: ModelVariant[], maxMode: boolean): ModelVariant | undefined;
 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>;

package/dist/models.js

@@ -1,6 +1,5 @@
 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 { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 /** Dedicated OpenCode provider-option key for a selected Cursor variant. */
@@ -59,11 +58,15 @@ export function normalizeModelParameterValues(value) {
     if (!Array.isArray(value))
         return null;
     const parameters = [];
+    const ids = new Set();
     for (const parameter of value) {
         if (!isPlainRecord(parameter))
             return null;
         if (!isNonEmptyString(parameter.id) || typeof parameter.value !== "string")
             return null;
+        if (ids.has(parameter.id))
+            return null;
+        ids.add(parameter.id);
         parameters.push({ id: parameter.id, value: parameter.value });
     }
     return parameters;
@@ -78,10 +81,12 @@ function normalizeVariant(value, fallbackName) {
     const displayName = optionalString(value, ["displayName", "display_name"]);
     const isDefaultNonMax = optionalBoolean(value, ["isDefaultNonMax", "isDefaultNonMaxConfig", "is_default_non_max_config"]);
     const isDefaultMax = optionalBoolean(value, ["isDefaultMax", "isDefaultMaxConfig", "is_default_max_config"]);
+    const isMaxMode = optionalBoolean(value, ["isMaxMode", "is_max_mode"]);
     if (key === null ||
         displayName === null ||
         isDefaultNonMax === null ||
-        isDefaultMax === null) {
+        isDefaultMax === null ||
+        isMaxMode === null) {
         return null;
     }
     if ((key !== undefined && !isNonEmptyString(key)) ||
@@ -94,6 +99,7 @@ function normalizeVariant(value, fallbackName) {
         parameterValues: parameters,
         isDefaultNonMax: isDefaultNonMax ?? false,
         isDefaultMax: isDefaultMax ?? false,
+        ...(isMaxMode === undefined ? {} : { isMaxMode }),
     };
 }
 function normalizeModelInfo(value) {
@@ -111,6 +117,7 @@ function normalizeModelInfo(value) {
     const supportsAgent = optionalBoolean(value, ["supportsAgent", "supports_agent"]);
     const supportsImages = optionalBoolean(value, ["supportsImages", "supports_images"]);
     const supportsMaxMode = optionalBoolean(value, ["supportsMaxMode", "supports_max_mode"]);
+    const supportsNonMaxMode = optionalBoolean(value, ["supportsNonMaxMode", "supports_non_max_mode"]);
     const maxContext = optionalPositiveNumber(value, ["maxContext", "contextTokenLimit", "context_token_limit"]);
     const maxContextForMaxMode = optionalPositiveNumber(value, ["maxContextForMaxMode", "contextTokenLimitForMaxMode", "context_token_limit_for_max_mode"]);
     if (displayName === null ||
@@ -119,6 +126,7 @@ function normalizeModelInfo(value) {
         supportsAgent === null ||
         supportsImages === null ||
         supportsMaxMode === null ||
+        supportsNonMaxMode === null ||
         maxContext === null ||
         maxContextForMaxMode === null) {
         return null;
@@ -133,6 +141,7 @@ function normalizeModelInfo(value) {
         ...(maxContext === undefined ? {} : { maxContext }),
         ...(maxContextForMaxMode === undefined ? {} : { maxContextForMaxMode }),
         ...(supportsMaxMode === undefined ? {} : { supportsMaxMode }),
+        ...(supportsNonMaxMode === undefined ? {} : { supportsNonMaxMode }),
         variants: variants,
     };
 }
@@ -176,17 +185,37 @@ 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. */
+/**
+ * True when resolved params select the long-context (1m) tier. Fallback for
+ * variants without Cursor's `isMaxMode` marker.
+ */
 export function paramsImplyMaxMode(params) {
     return params.some((parameter) => parameter.id === "context" &&
         parseCursorContextLimit(parameter.value) === 1_000_000);
 }
+function sameParameterTuple(a, b) {
+    const byId = new Map(b.map((parameter) => [parameter.id, parameter.value]));
+    return (a.length === b.length &&
+        new Set(a.map((parameter) => parameter.id)).size === a.length &&
+        byId.size === b.length &&
+        a.every((parameter) => byId.get(parameter.id) === parameter.value));
+}
+/** Cursor's per-variant max-mode marker, else the 1m-context fallback. */
+function variantIsMaxMode(v) {
+    return v.isMaxMode ?? paramsImplyMaxMode(v.parameterValues);
+}
 /**
- * Resolve the request-level max_mode bit. An explicit variant pick owns the
- * context tier; otherwise a standalone maxMode hint may select max mode.
+ * Resolve the request-level max_mode bit. Like Cursor CLI, a cataloged variant
+ * requires max mode when Cursor marks it `isMaxMode` (Grok 4.7's 500k tier as
+ * well as 1m tiers) or the model does not support non-max mode. An explicit
+ * variant pick owns the context tier; otherwise a standalone maxMode hint may
+ * select max mode.
  */
 export function resolveVariantMaxMode(params, opts = {}) {
-    return paramsImplyMaxMode(params) || (opts.picked === undefined && opts.maxMode === true);
+    if (opts.model?.supportsNonMaxMode === false)
+        return true;
+    const marked = opts.model?.variants.find((v) => sameParameterTuple(v.parameterValues, params))?.isMaxMode;
+    return (marked ?? paramsImplyMaxMode(params)) || (opts.picked === undefined && opts.maxMode === true);
 }
 // 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
@@ -212,8 +241,28 @@ function variantContextTokens(v) {
     const raw = v?.parameterValues.find((p) => p.id === "context")?.value;
     return parseCursorContextLimit(raw);
 }
-function isLongContextVariant(v) {
-    return variantContextTokens(v) === 1_000_000;
+/** Same parameters as `target` except the ignored ids. */
+function isTwinOf(v, target, ignored) {
+    return (v.parameterValues.length === target.parameterValues.length &&
+        sameParameterTuple(v.parameterValues.filter((p) => !ignored.includes(p.id)), target.parameterValues.filter((p) => !ignored.includes(p.id))));
+}
+/**
+ * Find Cursor's declared default within a catalog subset, retaining its effort:
+ * the declared variant, else its speed twin, else its twin in another context
+ * tier (a 500k entry when the declared max default is 1m).
+ */
+export function findDefaultVariant(model, candidates, maxMode) {
+    const isDeclared = (v) => maxMode ? v.isDefaultMax : v.isDefaultNonMax;
+    const declared = model.variants.find(isDeclared);
+    return candidates.find(isDeclared) ??
+        (declared === undefined
+            ? undefined
+            : candidates.find((v) => isTwinOf(v, declared, ["fast"])) ??
+                candidates.find((v) => isTwinOf(v, declared, ["fast", "context"])));
+}
+/** Send an advertised tuple verbatim; never rewrite one of its values. */
+function copyParameters(parameters) {
+    return parameters.map((parameter) => ({ ...parameter }));
 }
 function positiveNumber(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0
@@ -286,27 +335,38 @@ export function mapAvailableModelsResponse(raw) {
             if (!parameterValues) {
                 throw new Error(`AvailableModels returned invalid parameter values for ${name}`);
             }
+            const isMaxMode = optionalBoolean(v, ["isMaxMode", "is_max_mode"]);
+            if (isMaxMode === null) {
+                throw new Error(`AvailableModels returned a non-boolean isMaxMode for ${name}`);
+            }
             variants.push({
                 key: name,
                 parameterValues,
                 displayName: (v.displayName ?? v.display_name ?? name),
                 isDefaultNonMax: apiBoolean(v, ["isDefaultNonMaxConfig", "is_default_non_max_config"]),
                 isDefaultMax: apiBoolean(v, ["isDefaultMaxConfig", "is_default_max_config"]),
+                ...(isMaxMode === undefined ? {} : { isMaxMode }),
             });
         }
         // 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
+        // Prefer a non-max 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) => variantContextTokens(v) !== 1_000_000)) ??
+            variantContextTokens(variants.find((v) => !variantIsMaxMode(v) && variantContextTokens(v) !== undefined &&
+                variantContextTokens(v) !== 1_000_000)) ??
             variantContextTokens(variants.find((v) => v.parameterValues.some((p) => p.id === "context")));
-        const variantMaxContext = variantContextTokens(variants.find((v) => v.isDefaultMax));
+        const variantMaxContext = variantContextTokens(variants.find((v) => v.isDefaultMax)) ??
+            variantContextTokens(variants.find((v) => variantIsMaxMode(v) && variantContextTokens(v) !== undefined));
         const supportsImages = optionalBoolean(e, ["supportsImages", "supports_images"]);
         if (supportsImages === null) {
             throw new Error(`AvailableModels returned invalid supportsImages for ${name}`);
         }
+        const supportsNonMaxMode = optionalBoolean(e, ["supportsNonMaxMode", "supports_non_max_mode"]);
+        if (supportsNonMaxMode === null) {
+            throw new Error(`AvailableModels returned invalid supportsNonMaxMode for ${name}`);
+        }
         models.push({
             id: name,
             displayName: (e.clientDisplayName ?? e.client_display_name ?? name),
@@ -317,6 +377,7 @@ export function mapAvailableModelsResponse(raw) {
             maxContextForMaxMode: variantMaxContext ??
                 positiveNumber(e.contextTokenLimitForMaxMode ?? e.context_token_limit_for_max_mode),
             supportsMaxMode: apiBoolean(e, ["supportsMaxMode", "supports_max_mode"]),
+            ...(supportsNonMaxMode === undefined ? {} : { supportsNonMaxMode }),
             variants,
         });
     }
@@ -344,51 +405,46 @@ export function resolveVariantParameters(model, opts = {}) {
         }
         return opts.reasoningEffort ? [{ id: "effort", value: opts.reasoningEffort }] : [];
     }
-    const effortOf = (v) => v.parameterValues.find((p) => p.id === "effort" || p.id === "reasoning")?.value;
+    const effortOf = (v) => v.parameterValues.find((p) => p.id === "effort" || p.id === "reasoning" || p.id === "reasoning_effort")?.value;
     const isFast = (v) => v.parameterValues.find((p) => p.id === "fast")?.value === "true";
-    const isMaxVariant = (v) => v.isDefaultMax || isLongContextVariant(v);
-    const wantMax = opts.maxMode ?? false;
-    // 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;
+    const wantMax = (opts.maxMode ?? false) || model.supportsNonMaxMode === false;
     // 1. Variant explicitly picked by opencode (verbatim — preserves context, fast, …).
     if (picked !== undefined) {
-        const pickedById = new Map(picked.map((parameter) => [parameter.id, parameter.value]));
-        const exact = model.variants.find((v) => v.parameterValues.length === picked.length &&
-            pickedById.size === picked.length &&
-            v.parameterValues.every((parameter) => pickedById.get(parameter.id) === parameter.value));
+        const exact = model.variants.find((v) => sameParameterTuple(v.parameterValues, picked));
         if (exact) {
-            return buildRequestedModelParams(exact.parameterValues);
+            return copyParameters(exact.parameterValues);
         }
         throw new CursorVariantSelectionError(`is stale for model ${JSON.stringify(model.id)}: its exact parameter tuple is unavailable`);
     }
-    // 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).
+    // Choose the tier before preferring non-Fast variants. Otherwise a Fast-only
+    // max tier disappears, or a leading max variant steals an effort-only hint.
+    // isDefaultMax is a preference, not a requirement to run in max mode.
+    const tier = model.variants.filter((v) => variantIsMaxMode(v) === wantMax);
+    const candidates = tier.length > 0 ? tier : model.variants;
+    const nonFast = candidates.filter((v) => !isFast(v));
+    const scoped = nonFast.length > 0 ? nonFast : candidates;
+    // Cursor can declare a Fast variant as a default (Grok, GPT max defaults);
+    // the tier default retains the declared default's effort when its speed
+    // twin is needed (same parameters except `fast`).
+    const byDefault = (wantMax
+        ? findDefaultVariant(model, scoped, true) ?? scoped.find(variantIsMaxMode)
+        : undefined) ?? findDefaultVariant(model, scoped, false) ?? scoped[0];
+    // 2. Effort hint (e.g. user passed reasoningEffort through the CLI). Like
+    // Cursor CLI, break ties toward the tier default so the hint changes only
+    // effort, not thinking or other parameters (Claude lists thinking=false first).
     if (opts.reasoningEffort) {
-        const match = effortPool.find((v) => effortOf(v) === opts.reasoningEffort);
+        const shared = (v) => v.parameterValues.filter((parameter) => byDefault.parameterValues.some((d) => d.id === parameter.id && d.value === parameter.value)).length;
+        const match = scoped
+            .filter((v) => effortOf(v) === opts.reasoningEffort)
+            .reduce((best, v) => best && shared(best) >= shared(v) ? best : v, undefined);
         if (match) {
-            return buildRequestedModelParams(match.parameterValues, {
-                reasoningEffort: opts.reasoningEffort,
-                maxMode: wantMax,
-            });
+            return copyParameters(match.parameterValues);
         }
     }
-    // 3. Max-mode hint → prefer the default max variant (1m context).
-    if (wantMax) {
-        const max = scoped.find((v) => v.isDefaultMax) ?? scoped.find(isLongContextVariant);
-        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: false,
-    });
+    // 3. Max-mode hint → the default max variant (the max tier).
+    // 4. Otherwise the default non-max variant, else the first candidate.
+    // An unsupported effort must not synthesize a tuple Cursor never advertised.
+    return copyParameters(byDefault.parameterValues);
 }
 // ── Fetch + cache orchestration ──
 export async function fetchModels(token, options = {}) {

package/dist/opencode2/tool-results.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Preserve native result status before OpenCode's AI SDK lowers errors to text.
+ * Upstream: https://github.com/anomalyco/opencode/blob/v2.0.27/packages/core/src/aisdk.ts#L652-L685
+ * Native part.providerMetadata becomes SDK part.providerOptions (same file, L717-L720).
+ */
+export type ToolRefusal = "permission_denied" | "rejected";
+export type NativeToolFailure = {
+    type: string;
+    text: string;
+    refusal?: ToolRefusal;
+};
+export declare const TOOL_RESULT_STATUS_KEY = "opencodeToolResult";
+export declare function nativeToolFailure(value: unknown, refusal?: ToolRefusal): NativeToolFailure;
+/** The native tool hook preserves the underlying typed permission cause. */
+export declare function nativeToolRefusal(error: unknown): ToolRefusal | undefined;
+/** Metadata travels with each part, including history and independently loaded SDK copies. */
+export declare function preserveNativeToolResults(messages: readonly unknown[] | undefined, refusals?: ReadonlyMap<string, ToolRefusal>): any[];
+export declare function toolResultFailure(options: unknown, callID: string): NativeToolFailure | undefined;