cursor-opencode-provider 0.6.2 → 0.6.4

package/README.md

@@ -338,7 +338,7 @@ const model = cursor.languageModel("composer-2.5")
 // model implements AI SDK LanguageModelV3 (doStream / doGenerate)
 ```
 
-Pass either `accessToken` (JWT from OAuth or key exchange) or `apiKey` (raw `crsr_...` key). Optional: `apiBaseURL`, `agentBaseURL`, `cacheDir`, `headers`, `telemetryEnabled`, `retry`, and `continuation`. `cacheDir` pins the host cache root for model/version caches and Cursor project metadata; when omitted, the provider uses an injected structural host path bridge or the native OpenCode XDG cache described in [Paths](#paths-host-cache). Transient failures resume from the latest checkpoint produced by that Run, matching Cursor CLI; without an eligible checkpoint, retries remain limited to replay-safe attempts so completed text or tool work is not duplicated. Pending-tool inactivity is renewed by OpenCode activity from the session or its descendants. The older `baseURL` option is still accepted as a legacy alias for `agentBaseURL`.
+Pass either `accessToken` (JWT from OAuth or key exchange) or `apiKey` (raw `crsr_...` key). Optional: `apiBaseURL`, `agentBaseURL`, `cacheDir`, `headers`, `telemetryEnabled`, `retry`, and `continuation`. `cacheDir` pins the host cache root for model/version caches and Cursor project metadata; when omitted, the provider uses an injected structural host path bridge or the native OpenCode XDG cache described in [Paths](#paths-host-cache). Transient failures resume from the latest checkpoint produced by that Run, matching Cursor CLI; without an eligible checkpoint, retries remain limited to replay-safe attempts so completed text or tool work is not duplicated. Once that budget is spent, or replay is unsafe, the terminal error does not re-arm OpenCode's outer retry loop. Pending-tool inactivity is renewed by OpenCode activity from the session or its descendants. The older `baseURL` option is still accepted as a legacy alias for `agentBaseURL`.
 
 ## Environment variables
 

package/dist/errors.d.ts

@@ -43,6 +43,16 @@ export declare class CursorAuthError extends CursorProviderError {
         cause?: unknown;
     });
 }
+/**
+ * OpenCode's SessionRetry treats several substrings in provider error messages
+ * as always-retryable — notably bare "unavailable" and "exhausted", plus a
+ * broader regex set (resource_exhausted, service unavailable, …).
+ *
+ * When this provider has already spent its Run retry budget, or has decided a
+ * replay would be unsafe, the host-facing message must not re-arm that loop.
+ * Keep the real gRPC/HTTP code on structured fields (`code`, `grpcStatus`).
+ */
+export declare function sanitizeHostTerminalMessage(message: string): string;
 export declare class CursorRetryExhaustedError extends CursorProviderError {
     readonly attempts: number;
     constructor(attempts: number, last: CursorProviderError);

package/dist/errors.js

@@ -69,10 +69,30 @@ export class CursorAuthError extends CursorProviderError {
         this.name = "CursorAuthError";
     }
 }
+/**
+ * OpenCode's SessionRetry treats several substrings in provider error messages
+ * as always-retryable — notably bare "unavailable" and "exhausted", plus a
+ * broader regex set (resource_exhausted, service unavailable, …).
+ *
+ * When this provider has already spent its Run retry budget, or has decided a
+ * replay would be unsafe, the host-facing message must not re-arm that loop.
+ * Keep the real gRPC/HTTP code on structured fields (`code`, `grpcStatus`).
+ */
+export function sanitizeHostTerminalMessage(message) {
+    return message
+        .replace(/\bresource[_\s-]?exhausted\b/gi, "capacity_limit")
+        .replace(/\bservice[_\s-]?unavailable\b/gi, "capacity_limit")
+        .replace(/\bunavailable\b/gi, "capacity_limit")
+        .replace(/\boverloaded\b/gi, "capacity_limit")
+        .replace(/\bretry exhausted\b/gi, "retries finished")
+        .replace(/\bexhausted\b/gi, "finished");
+}
 export class CursorRetryExhaustedError extends CursorProviderError {
     attempts;
     constructor(attempts, last) {
-        super(`Cursor retry exhausted after ${attempts} attempts: ${last.message}`, {
+        // Host-facing text must not contain OpenCode SessionRetry trigger words
+        // ("unavailable", "exhausted", …). Structured fields keep the real code.
+        super(`Cursor Run failed after ${attempts} attempts: ${sanitizeHostTerminalMessage(last.message)}`, {
             origin: last.origin,
             transient: false,
             replaySafe: false,
@@ -184,7 +204,7 @@ export function toCursorProviderError(error, options = { replaySafe: false }) {
     });
 }
 export function retrySuppressedError(cause, reason, attempt, maxAttempts) {
-    const subject = cause.message.replace(/^Cursor Run stream /, "Cursor stream ");
+    const subject = sanitizeHostTerminalMessage(cause.message.replace(/^Cursor Run stream /, "Cursor stream "));
     return new CursorProviderError(`${subject} ${reason}; automatic retry unsafe (attempt ${attempt}/${maxAttempts})`, {
         origin: cause.origin,
         transient: false,

package/dist/language-model.js

@@ -26,7 +26,7 @@ import { clearPersistedConversationState, hydrateConversationState, persistConve
 import { initializeConversationPersistence } from "./protocol/conversation-persistence.js";
 import { resolveContinuationPolicy, sessionManager, } from "./session.js";
 import { CursorAuthError, CursorLocalCancellationError, CursorProtocolError, CursorProviderError, CursorRetryExhaustedError, CursorServerError, CursorTransportError, isTransientGrpcStatus, retrySuppressedError, toCursorProviderError, } from "./errors.js";
-import { readCache, cacheFilePath, resolveVariantParameters, paramsImplyMaxMode, extractCursorVariantParameters, resolveCursorWireModelId } from "./models.js";
+import { readCache, cacheFilePath, resolveVariantParameters, resolveVariantMaxMode, extractCursorVariantParameters, resolveCursorWireModelId } from "./models.js";
 import { getOrBuildRequestContext } from "./context/frozen.js";
 import { workspaceRootFromRequestContext } from "./context/env.js";
 import { ensureOpencodeProjectDir, opencodeGlobalCacheDir, setHostCacheDirOverride, } from "./context/paths.js";
@@ -760,9 +760,12 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         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);
+    // An explicit pick owns the context tier; otherwise honor the maxMode hint.
+    // OpenCode's variant paramMap does not include maxMode when the user selects 1m.
+    const maxMode = resolveVariantMaxMode(parameterValues, {
+        picked,
+        maxMode: hintMaxMode,
+    });
     // 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.

package/dist/models.d.ts

@@ -47,6 +47,14 @@ export declare function extractCursorVariantParameters(providerOptions: Record<s
 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;
+/**
+ * Resolve the request-level max_mode bit. 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;
+}): boolean;
 export declare function parseCursorContextLimit(value: unknown): number | undefined;
 export declare function isCacheFresh(cache: ModelCache, ttlMs?: number): boolean;
 export declare function cacheFilePath(cacheDir: string): string;

package/dist/models.js

@@ -181,6 +181,13 @@ export function paramsImplyMaxMode(params) {
     return params.some((parameter) => parameter.id === "context" &&
         parseCursorContextLimit(parameter.value) === 1_000_000);
 }
+/**
+ * Resolve the request-level max_mode bit. 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);
+}
 // 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
@@ -352,10 +359,7 @@ export function resolveVariantParameters(model, opts = {}) {
             pickedById.size === picked.length &&
             v.parameterValues.every((parameter) => pickedById.get(parameter.id) === parameter.value));
         if (exact) {
-            return buildRequestedModelParams(exact.parameterValues, {
-                reasoningEffort: opts.reasoningEffort,
-                maxMode: wantMax,
-            });
+            return buildRequestedModelParams(exact.parameterValues);
         }
         throw new CursorVariantSelectionError(`is stale for model ${JSON.stringify(model.id)}: its exact parameter tuple is unavailable`);
     }

package/dist/pricing-data.d.ts

@@ -171,15 +171,15 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly cache_write: 0.25;
     };
     readonly "gpt-5.6-sol": {
-        readonly input: 5;
-        readonly output: 30;
-        readonly cache_read: 0.5;
-        readonly cache_write: 6.25;
+        readonly input: 4;
+        readonly output: 20;
+        readonly cache_read: 0.4;
+        readonly cache_write: 5;
         readonly context_over_200k: {
-            readonly input: 10;
-            readonly output: 30;
-            readonly cache_read: 1;
-            readonly cache_write: 12.5;
+            readonly input: 8;
+            readonly output: 20;
+            readonly cache_read: 0.8;
+            readonly cache_write: 10;
         };
     };
     readonly "gpt-5.6-terra": {
@@ -360,9 +360,6 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "composer-2.5": {
         readonly supportsImages: true;
     };
-    readonly default: {
-        readonly supportsImages: false;
-    };
     readonly "gemini-2.5-flash": {
         readonly supportsImages: true;
     };

package/dist/pricing-data.js

@@ -171,15 +171,15 @@ export const CURSOR_MODEL_COSTS = {
         "cache_write": 0.25
     },
     "gpt-5.6-sol": {
-        "input": 5,
-        "output": 30,
-        "cache_read": 0.5,
-        "cache_write": 6.25,
+        "input": 4,
+        "output": 20,
+        "cache_read": 0.4,
+        "cache_write": 5,
         "context_over_200k": {
-            "input": 10,
-            "output": 30,
-            "cache_read": 1,
-            "cache_write": 12.5
+            "input": 8,
+            "output": 20,
+            "cache_read": 0.8,
+            "cache_write": 10
         }
     },
     "gpt-5.6-terra": {
@@ -360,9 +360,6 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "composer-2.5": {
         "supportsImages": true
     },
-    "default": {
-        "supportsImages": false
-    },
     "gemini-2.5-flash": {
         "supportsImages": true
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",