cursor-opencode-provider 0.4.2 → 0.4.3

package/README.md

@@ -460,7 +460,7 @@ The package root intentionally stays plugin-safe for OpenCode's classic loader.
 | Visible `<shell_metadata>` timeout text | Rebuild and restart a local install. Cursor's shell timeout is carried on its exec request; the provider now removes OpenCode's internal timeout envelope before it is rendered or stored, then returns Cursor's typed timeout or background-handoff event instead of treating the text as successful stdout. |
 | `Unsupported Cursor exec variant …` | The error names the canonical Cursor CLI request field, its expected result field, and this provider's handling classification. `handling=unsupported` is a known Cursor-native capability without a safe OpenCode AI SDK bridge; `unknown request field` indicates new protocol drift; `handling=opencode-tool` or `provider-control` indicates a provider decoder/dispatch regression. Enable the debug log and report the full named error. |
 | Need wire-level logs | Set `CURSOR_PROVIDER_DEBUG=1` (optional `CURSOR_PROVIDER_DEBUG_FILE`; the default is `debug-<pid>.log` under `$TMPDIR/cursor-provider-logs-<uid>/`) and reproduce the issue. |
-| OpenCode compacts immediately after a tool-heavy task | Upgrade to a version containing the cumulative-usage fix. Cursor's final `TurnEnded` counters cover the entire held multi-step Run; older provider versions exposed that aggregate as the final request's context size, which made OpenCode compact far too early. Fixed versions keep the raw counters in `providerMetadata.cursor` and report a request-local context estimate instead. |
+| OpenCode compacts immediately after a tool-heavy task | Upgrade to a version containing the cumulative-usage fix. Cursor's final `TurnEnded` counters cover the entire held multi-step Run; older provider versions exposed that aggregate as the final request's context size, which made OpenCode compact far too early. Fixed versions keep the raw counters in `providerMetadata.cursor` and report a request-local context estimate instead. An over-budget guard also catches single-step or parallel Runs whose counters are cumulative even without a visible tool boundary. |
 | Cache **write** tokens always show as `0` | Cursor's `TurnEnded` protobuf includes `cache_write` (field 4), but captured Runs set it to `0` even when `cache_read` is large. Single-step Runs expose those counters directly. For multi-step Runs they remain in `providerMetadata.cursor` because Cursor reports only a cumulative whole-Run total, which cannot safely be used as one OpenCode request's context usage. With debug logging, confirm `turn_ended raw wire fields: … f4:wt0=0`. |
 
 ## Security
@@ -470,7 +470,7 @@ Project `instructions` may reference absolute or `~/` paths (OpenCode parity). S
 ## Known limitations
 
 - **Personal use / ToS** — this provider speaks Cursor’s private agent protocol (CLI-shaped client identity). Use only with an account you own; Cursor may change or restrict the API without notice.
-- **`TurnEnded` usage is whole-Run usage** — on a held multi-step Cursor Run, the final `interaction_update.turn_ended` counters aggregate every model invocation across tool boundaries. OpenCode usage is request-local and uses the latest assistant message to decide compaction, so publishing the aggregate there both double-counts earlier steps and causes premature compaction. The provider therefore uses a current-context estimate for multi-step AI SDK usage and preserves the exact cumulative counters in `providerMetadata.cursor`; single-step Runs still map the counters directly. Cursor also consistently sends `cache_write=0` in captured Runs, so no alternate write count is available.
+- **`TurnEnded` usage is whole-Run usage** — on a held multi-step Cursor Run, the final `interaction_update.turn_ended` counters aggregate every model invocation across tool boundaries. OpenCode usage is request-local and uses the latest assistant message to decide compaction, so publishing the aggregate there both double-counts earlier steps and causes premature compaction. The provider therefore uses a current-context estimate for multi-step AI SDK usage and preserves the exact cumulative counters in `providerMetadata.cursor`; single-step Runs map the counters directly only when they are close to the request-local estimate, while an over-budget guard handles cumulative no-boundary Runs. Cursor also consistently sends `cache_write=0` in captured Runs, so no alternate write count is available.
 - **`request_context` from OpenCode** — each Run sends Cursor `RequestContext` built from OpenCode project context (workspace env, `AGENTS.md` / `instructions`, `.opencode` agents/skills/plugins, git, layout, plus `.claude`/`.agents` skill fallbacks). Its canonical root is also used by the [injected system guidance](#injected-system-guidance). Same discovery as OpenCode — including `.cursor/` paths only when listed in `instructions`. Cursor-only cloud/sandbox marketplace surfaces are omitted. `env.workspace_paths` / `process_working_directory` stay on the real git workspace; Cursor's metadata root (`project_folder`, MCP `workspace_project_dir`, terminals/transcripts) is advertised under `<host-cache>/projects/<slug>/` (default `~/.cache/opencode/projects/…`) so dumps like `agent-tools/` do not land in the repo. OpenCode remains the permission authority: its coarse allow/ask/deny configuration is not fabricated into Cursor's unrelated allow/block instruction-list messages.
 - **Configured MCP tools keep their upstream server id** — OpenCode builtins and plugin/custom tools are advertised under a synthetic `opencode` MCP server. Tools whose flattened name matches an MCP server in merged `opencode.json` configuration (`github_create_pull_request`, …) are grouped into that server's `mcp_descriptors` / `provider_identifier` (`github`, …). Unknown underscore-containing names stay under `opencode` rather than being guessed incorrectly. Cursor's MCP-state exec probe is answered from the same advertised descriptors before the actual tool request, using the full canonical tool-definition identity required by native `get_mcp_tools`; exec still reconstructs the full OpenCode tool id.
 - **Display completions are notifications, not execution requests** — Cursor `tool_call_*` frames use a typed `ToolCall` oneof. The provider decodes them for diagnostics but only mirrors finalized todo/plan state (`update_todos_tool_call` / `create_plan_tool_call`) into advertised OpenCode `todowrite`; the completed payload already contains the authoritative final list. Interactive, data-returning, and side-effecting completions are never replayed as new tools because their result could not be returned to Cursor. Exec-backed native subagent/Task and Pi read/bash/edit/write/grep/find/ls calls use their typed request/result fields instead. Unknown display variants are logged. All 37 Cursor CLI exec request/result pairs are inventoried by field and name; known-but-unsupported and future unknown exec variants fail explicitly rather than receiving a guessed response that could deadlock the Run.

package/dist/language-model.js

@@ -29,7 +29,7 @@ import { resolveCursorModelSupportsImages } from "./model-metadata.js";
 import { consumeCursorShellResult, registerCursorShellCall, } from "./shell-timeout.js";
 import { analyzeReplayFrame, AttemptReplaySafety } from "./replay-safety.js";
 import { readAllFieldsStrict } from "./protocol/struct.js";
-import { buildLanguageModelV3UsageFromEstimate, buildLanguageModelV3UsageFromTurnEnded, turnEndedCounter, } from "./usage.js";
+import { buildLanguageModelV3UsageFromEstimate, buildLanguageModelV3UsageFromTurnEnded, exceedsRequestLocalBudget, turnEndedCounter, } from "./usage.js";
 let _availableModels;
 // mtime of the cache file the last time we loaded it. Compared on each call
 // so discoverModels' background refresh is picked up without a process restart.
@@ -1164,7 +1164,12 @@ export async function pump(session, controller, ids, abortSignal) {
         // a tool boundary. On a held multi-step Run Cursor aggregates every model
         // invocation into these counters; treating that billed total as the final
         // request's prompt size makes OpenCode compact after ordinary tasks.
-        const cumulativeTurnEnded = !!te && session.hadToolCallBoundary === true;
+        const cumulativeByBoundary = !!te && session.hadToolCallBoundary === true;
+        const cumulativeByBudget = !!te && !cumulativeByBoundary && exceedsRequestLocalBudget(te, {
+            inputTokens: session.usageEstimate.inputTokens,
+            outputTokens: session.usageEstimate.outputTokens,
+        });
+        const cumulativeTurnEnded = cumulativeByBoundary || cumulativeByBudget;
         if (te && !cumulativeTurnEnded) {
             session.usageEstimate = {
                 inputTokens: turnEndedCounter(te, "input_tokens"),
@@ -1194,6 +1199,7 @@ export async function pump(session, controller, ids, abortSignal) {
             `rawOut=${te ? turnEndedCounter(te, "output_tokens") : est.outputTokens} ` +
             `rawCacheRead=${te ? turnEndedCounter(te, "cache_read") : est.cacheRead} ` +
             `rawCacheWrite=${te ? turnEndedCounter(te, "cache_write") : est.cacheWrite} ` +
+            `guard=${cumulativeByBoundary ? "boundary" : cumulativeByBudget ? "over-budget" : "none"} ` +
             `source=${te ? (cumulativeTurnEnded ? "estimate-cumulative-turn-ended" : "turn_ended") : "estimate"}`);
         safeEnqueue({
             type: "finish",
@@ -1822,6 +1828,9 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
         // leaving the turn with no file-editing guidance at all.
         instructions.push("- Use OpenCode `apply_patch` for file-content changes; do not use shell, Python, or heredocs to change file content while it is available. Cursor-native write and edit requests are accepted and converted to `apply_patch` automatically.");
     }
+    if (names.has("edit") || names.has("write") || names.has("apply_patch")) {
+        instructions.push("- Never use a read result as complete file content when it says the output is capped, partial, or requires another offset. Read the remaining ranges first, or make a targeted edit/patch from complete context; do not pass a partial read back as a whole-file replacement.");
+    }
     return [
         `OpenCode exposes exactly these executable tools for this turn: ${[...names].map((name) => `\`${name}\``).join(", ")}.`,
         `Workspace root: ${JSON.stringify(workspaceRoot)}. Resolve workspace paths against exactly this root; never invent an absolute prefix, and verify uncertain paths with an available tool before using them.`,

package/dist/pricing-data.d.ts

@@ -303,6 +303,9 @@ export declare const CURSOR_MODEL_CONTEXTS: {
     readonly "grok-4.5": {
         readonly maxContext: 256000;
     };
+    readonly "grok-4.6": {
+        readonly maxContext: 256000;
+    };
     readonly "kimi-k2.7-code": {
         readonly maxContext: 262000;
     };
@@ -405,6 +408,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "grok-4.5": {
         readonly supportsImages: false;
     };
+    readonly "grok-4.6": {
+        readonly supportsImages: false;
+    };
     readonly "kimi-k2.7-code": {
         readonly supportsImages: true;
     };

package/dist/pricing-data.js

@@ -303,6 +303,9 @@ export const CURSOR_MODEL_CONTEXTS = {
     "grok-4.5": {
         "maxContext": 256000
     },
+    "grok-4.6": {
+        "maxContext": 256000
+    },
     "kimi-k2.7-code": {
         "maxContext": 262000
     },
@@ -405,6 +408,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "grok-4.5": {
         "supportsImages": false
     },
+    "grok-4.6": {
+        "supportsImages": false
+    },
     "kimi-k2.7-code": {
         "supportsImages": true
     },

package/dist/pricing.d.ts

@@ -34,7 +34,7 @@ export type CursorPricingCoverage = {
  * Models we expose that Cursor does not currently publish numeric rates for
  * on the Other Models table (Auto / first-party Cursor Models pool).
  */
-export declare const CURSOR_UNPRICED_MODEL_IDS: readonly ["default", "composer-2.5", "grok-4.5"];
+export declare const CURSOR_UNPRICED_MODEL_IDS: readonly ["default", "composer-2.5", "grok-4.5", "grok-4.6"];
 export declare function validateOpenCodeModelCost(value: unknown, path?: string): {
     valid: boolean;
     errors: string[];

package/dist/pricing.js

@@ -10,7 +10,7 @@ import { CURSOR_MODEL_COSTS } from "./pricing-data.js";
  * Models we expose that Cursor does not currently publish numeric rates for
  * on the Other Models table (Auto / first-party Cursor Models pool).
  */
-export const CURSOR_UNPRICED_MODEL_IDS = ["default", "composer-2.5", "grok-4.5"];
+export const CURSOR_UNPRICED_MODEL_IDS = ["default", "composer-2.5", "grok-4.5", "grok-4.6"];
 const UNPRICED = new Set(CURSOR_UNPRICED_MODEL_IDS);
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/usage.d.ts

@@ -19,6 +19,21 @@ export type CursorUsageEstimate = {
     cacheWrite: number;
     reasoningTokens: number;
 };
+/**
+ * A single-step trust path for TurnEnded counters is only safe when the
+ * totals are close to the request-local budget. Cursor reports cumulative
+ * conversation/Run totals even on Runs that never crossed an OpenCode tool
+ * boundary: single-step follow-up turns and parallel no-tools side calls
+ * carry the whole conversation's `cache_read`. Treating those totals as
+ * request-local inflates OpenCode's context usage and triggers premature
+ * compaction (issue #20).
+ */
+export declare const CUMULATIVE_TURN_ENDED_RATIO = 3;
+export declare const MIN_TRUSTED_TURN_ENDED_TOTAL = 1024;
+export declare function exceedsRequestLocalBudget(te: Record<string, unknown>, budget: {
+    inputTokens: number;
+    outputTokens: number;
+}): boolean;
 /**
  * Request-local usage for a held Cursor Run.
  *

package/dist/usage.js

@@ -35,6 +35,30 @@ export function buildLanguageModelV3UsageFromTurnEnded(te) {
         },
     };
 }
+/**
+ * A single-step trust path for TurnEnded counters is only safe when the
+ * totals are close to the request-local budget. Cursor reports cumulative
+ * conversation/Run totals even on Runs that never crossed an OpenCode tool
+ * boundary: single-step follow-up turns and parallel no-tools side calls
+ * carry the whole conversation's `cache_read`. Treating those totals as
+ * request-local inflates OpenCode's context usage and triggers premature
+ * compaction (issue #20).
+ */
+export const CUMULATIVE_TURN_ENDED_RATIO = 3;
+export const MIN_TRUSTED_TURN_ENDED_TOTAL = 1024;
+export function exceedsRequestLocalBudget(te, budget) {
+    const total = turnEndedCounter(te, "input_tokens") +
+        turnEndedCounter(te, "cache_read") +
+        turnEndedCounter(te, "cache_write");
+    const requestLocal = budget.inputTokens + budget.outputTokens;
+    // Skip when the request-local seed is unknown; otherwise compare against
+    // max(ratio × request-local, absolute floor) so tiny prompts still reject
+    // multi-million-token conversation cache totals.
+    if (requestLocal <= 0)
+        return false;
+    const trustCeiling = Math.max(requestLocal * CUMULATIVE_TURN_ENDED_RATIO, MIN_TRUSTED_TURN_ENDED_TOTAL);
+    return total > trustCeiling;
+}
 /**
  * Request-local usage for a held Cursor Run.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -92,6 +92,7 @@
     "@opencode-ai/plugin": "^1.18.16",
     "@opencode-ai/plugin-next": "npm:@opencode-ai/plugin@0.0.0-next-17155",
     "@tsconfig/node22": "^22.0.5",
+    "@types/bun": "^1.3.0",
     "@types/node": "^22.20.1",
     "typescript": "^5.9.3"
   }