cursor-opencode-provider 0.8.0 → 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
@@ -8,10 +9,20 @@ import { type ModelInfo, type ModelVariant } from "./models.js";
  * tagged redundantly.
  */
 export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string>;
+/**
+ * models.dev-style family for a Cursor model id: the id without its version
+ * segments and context/speed suffixes (`claude-haiku-4-5` → `claude-haiku`,
+ * `gemini-3.8-flash` → `gemini-flash`, `gpt-5.6-luna` → `gpt-luna`).
+ * Kimi keeps its major generation (`kimi-k2.7-code` → `kimi-k2`). OpenCode
+ * picks its small title model by family and falls back to the session model when
+ * no entry has one. Cursor Auto (`default`) is not a model family.
+ */
+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";
 /**
@@ -91,7 +91,7 @@ function modelInfoVariants(mi, variants) {
         // 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`;
+            key = `${baseName}${tagDims(v.parameterValues) || " default"}`;
         }
         else if (usedKeys.has(key)) {
             key = `${sanitized}${tagDims(v.parameterValues)}`;
@@ -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
@@ -140,6 +155,27 @@ export function thinkingSuffixBaseNames(models) {
             ambiguous.add(base);
     return ambiguous;
 }
+/**
+ * models.dev-style family for a Cursor model id: the id without its version
+ * segments and context/speed suffixes (`claude-haiku-4-5` → `claude-haiku`,
+ * `gemini-3.8-flash` → `gemini-flash`, `gpt-5.6-luna` → `gpt-luna`).
+ * Kimi keeps its major generation (`kimi-k2.7-code` → `kimi-k2`). OpenCode
+ * picks its small title model by family and falls back to the session model when
+ * no entry has one. Cursor Auto (`default`) is not a model family.
+ */
+export function cursorModelFamily(id) {
+    if (id === "default")
+        return undefined;
+    const base = id.replace(/(?:-(?:1m|fast))+$/, "");
+    const kimi = /^kimi-(k\d+)(?:[.p]\d+)*(?:-code(?:-highspeed)?)?$/.exec(base);
+    if (kimi)
+        return `kimi-${kimi[1]}`;
+    const family = base
+        .split("-")
+        .filter((part) => !/^\d+(?:[.p]\d+)*$/.test(part))
+        .join("-");
+    return family || undefined;
+}
 export function modelInfoToConfig(mi, options = {}) {
     const contextTier = options.contextTier ?? "base";
     const variants = options.variants ?? variantsForTier(mi, contextTier);
@@ -150,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.
@@ -158,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
@@ -182,13 +223,17 @@ export function modelInfoToConfig(mi, options = {}) {
             output,
         },
     };
+    // Optional cache metadata may supply a family; the live AvailableModels
+    // schema has no family field. Empty metadata must not block derivation.
+    const reported = typeof mi.family === "string" ? mi.family.trim() : "";
+    const family = reported || cursorModelFamily(mi.id);
+    if (family)
+        config.family = family;
     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,
@@ -218,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;
@@ -238,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),
                 });
             }
@@ -266,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>;