cursor-opencode-provider 0.4.0 → 0.4.1

package/README.md

@@ -48,7 +48,7 @@ Add the package to OpenCode config. OpenCode installs npm plugins with Bun at st
 }
 ```
 
-Pin a version if you want: `"cursor-opencode-provider@0.4.0"`.
+Pin a version if you want: `"cursor-opencode-provider@0.4.1"`.
 
 You can also install it yourself first:
 
@@ -118,7 +118,7 @@ browser login or an API key. `CURSOR_API_KEY` is also picked up automatically.
 }
 ```
 
-Pin a version if you want: `"cursor-opencode-provider@0.4.0/plugin/opencode2"`.
+Pin a version if you want: `"cursor-opencode-provider@0.4.1/plugin/opencode2"`.
 
 OpenCode 2.0 installs the published package into its host cache and loads the AI SDK
 entry from there (`aisdk:cursor-opencode-provider`). No extra env vars are required.
@@ -379,11 +379,17 @@ The provider adds OpenCode-specific system guidance to normal tool-capable conve
 
 If this guidance causes issues, update `buildOpenCodeInteractionGuidance` in [`src/language-model.ts`](src/language-model.ts) and its focused coverage in [`test/prompt-history.test.ts`](test/prompt-history.test.ts).
 
+### Cursor edit handshakes
+
+Cursor's legacy `edit_tool_call` is implemented internally as a correlated `read_args` followed by a whole-file `write_args`; the write is transport mechanics, not a new decision to replace OpenCode's `edit` tool. The provider retains that correlation and exposes an existing-file mutation as one unique, line-bounded OpenCode `edit`. It still returns Cursor's expected typed `write_result`. New-file creation remains a `write`, and an `apply_patch`-only catalog receives the same targeted change as an `*** Update File:` patch.
+
+The prerequisite native read also preserves an existing final LF/CRLF. OpenCode's numbered read envelope cannot represent that terminator, and dropping it made Cursor's exact edit matcher reject valid replacements, retry reads, and eventually rewrite the file. This restoration applies only to confirmed-complete, unbounded reads; paged and capped reads keep their existing truncation behavior.
+
 ### `apply_patch` models (GPT-5 and friends)
 
 OpenCode 1.x does not simply add `apply_patch` for GPT-series models — it **removes** `edit` and `write` from the tool catalog and advertises `apply_patch` in their place (`ToolRegistry.tools`; the model id must contain `gpt-` and neither `oss` nor `gpt-4`). Cursor keeps sending its native write/edit requests regardless, so without translation every file change on a `gpt-5*` model is refused as an unavailable tool.
 
-The provider translates transparently: a native write becomes an `*** Add File:` patch, and a Pi edit becomes a minimal `*** Update File:` chunk widened to whole lines. This is keyed purely off what the host advertises — it is inert whenever `edit`/`write` are offered normally, and inert again when the host offers neither those nor `apply_patch`. An edit that cannot be expressed faithfully (target unreadable, or the text to replace is absent or ambiguous) is refused with a specific message rather than applied to the wrong region.
+The provider translates transparently: an uncorrelated native write becomes an `*** Add File:` patch, while a correlated legacy edit or Pi edit becomes a minimal `*** Update File:` chunk widened to whole lines. This is keyed purely off what the host advertises — it is inert whenever `edit`/`write` are offered normally, and inert again when the host offers neither those nor `apply_patch`. An edit that cannot be expressed faithfully (target unreadable, or the text to replace is absent or ambiguous) is refused with a specific message rather than applied to the wrong region.
 
 OpenCode 2.0 does not perform this substitution, so the path is 1.x-only in practice. See [`src/protocol/apply-patch.ts`](src/protocol/apply-patch.ts) for the upstream references.
 
@@ -425,7 +431,8 @@ 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. |
-| Cache **write** tokens always show as `0` | Not a mapping bug in this provider. Cursor's `TurnEnded` protobuf includes `cache_write` (field 4) and this package forwards it as AI SDK `inputTokens.cacheWrite` / OpenCode `cache.write`. Real agent sessions send field 4 as `0` even when `cache_read` is large on later turns. With debug logging, confirm `turn_ended raw wire fields: … f4:wt0=0` and `v3CacheWrite=0 source=turn_ended`. Cache **read** counts from the same message do populate correctly. |
+| 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. |
+| 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
 
@@ -434,7 +441,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.cache_write` is unused by Cursor's agent** — usage comes from `interaction_update.turn_ended` (`input_tokens`, `output_tokens`, `cache_read`, `cache_write`, `reasoning_tokens`). The provider maps those 1:1 into AI SDK V3 nested usage. Captured live Runs consistently set `cache_write=0` on the wire while still reporting non-zero `cache_read` and `reasoning_tokens`; there is no alternate agent-stream field today that supplies write counts, so OpenCode/Kilo cannot show cache-write tokens for this provider until Cursor populates that counter.
+- **`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.
 - **`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/context/paths.d.ts

@@ -26,15 +26,32 @@ type CompatDetector = () => CompatDetectResult;
  */
 export declare function setHostCacheDirOverride(dir: string | undefined): void;
 export declare function getHostCacheDirOverride(): string | undefined;
+declare const HOST_CACHE_DIRS: readonly ["mimocode", "kilo", "opencode"];
+export type HostCacheDir = (typeof HOST_CACHE_DIRS)[number];
+/**
+ * Host cache-dir name inferred from the running binary (`argv[0]` /
+ * `process.execPath`). A source-checkout provider can't be located by install
+ * path, but the binary that loaded it is authoritative: when this process IS
+ * `mimo` / `kilocode`, the cache root is that host's, not OpenCode's. Mirrors
+ * OCP `detect()` binaryHint semantics and tolerates the leading-dot Kilo binary
+ * (`.kilo`). Only `argv[0]` is inspected — later argv entries are arguments,
+ * not binary identity, and could otherwise cause false positives (e.g. an
+ * `--opencode-config=…` flag under a fork).
+ */
+export declare function hostCacheDirFromProcess(argv?: readonly string[], execPath?: string): HostCacheDir | undefined;
 /**
  * Resolve the host cache directory without an override.
  *
  * Explicit host environment wins. Otherwise, an installed provider inherits
- * the host-named cache containing its module. A source checkout or otherwise
- * unidentifiable install defaults to OpenCode. Merely having another host's
- * config directory installed is not evidence that it owns this process.
+ * the host-named cache containing its module; a source checkout is attributed
+ * by the running binary identity (see {@link hostCacheDirFromProcess}). Merely
+ * having another host's config directory installed is not evidence that it
+ * owns this process.
  */
-export declare function resolveHostCacheDir(env?: HostPathEnv, moduleUrl?: string): string;
+export declare function resolveHostCacheDir(env?: HostPathEnv, moduleUrl?: string, processIdentity?: {
+    argv?: readonly string[];
+    execPath?: string;
+}): string;
 /**
  * Best-effort: if `@opencode-compat/profile` is installed, adopt `detect().profile.paths.cacheDir`
  * when the host is supported. No-op when OCP is absent or detection fails.

package/dist/context/paths.js

@@ -48,15 +48,52 @@ export function setHostCacheDirOverride(dir) {
 export function getHostCacheDirOverride() {
     return hostCacheDirOverride;
 }
+const HOST_CACHE_DIRS = ["mimocode", "kilo", "opencode"];
+/**
+ * Host cache-dir name inferred from the running binary (`argv[0]` /
+ * `process.execPath`). A source-checkout provider can't be located by install
+ * path, but the binary that loaded it is authoritative: when this process IS
+ * `mimo` / `kilocode`, the cache root is that host's, not OpenCode's. Mirrors
+ * OCP `detect()` binaryHint semantics and tolerates the leading-dot Kilo binary
+ * (`.kilo`). Only `argv[0]` is inspected — later argv entries are arguments,
+ * not binary identity, and could otherwise cause false positives (e.g. an
+ * `--opencode-config=…` flag under a fork).
+ */
+export function hostCacheDirFromProcess(argv = process.argv, execPath = process.execPath) {
+    for (const raw of [argv[0], execPath]) {
+        if (!raw)
+            continue;
+        const name = path.basename(String(raw)).toLowerCase().replace(/^\.+/, "");
+        if (name === "mimo" ||
+            name === "mimocode" ||
+            name.startsWith("mimo-") ||
+            name.includes("mimocode")) {
+            return "mimocode";
+        }
+        if (name === "kilo" ||
+            name === "kilocode" ||
+            name.startsWith("kilo-") ||
+            name.includes("kilocode")) {
+            return "kilo";
+        }
+        if (name === "opencode" ||
+            name.startsWith("opencode-") ||
+            name.includes("opencode")) {
+            return "opencode";
+        }
+    }
+    return undefined;
+}
 /**
  * Resolve the host cache directory without an override.
  *
  * Explicit host environment wins. Otherwise, an installed provider inherits
- * the host-named cache containing its module. A source checkout or otherwise
- * unidentifiable install defaults to OpenCode. Merely having another host's
- * config directory installed is not evidence that it owns this process.
+ * the host-named cache containing its module; a source checkout is attributed
+ * by the running binary identity (see {@link hostCacheDirFromProcess}). Merely
+ * having another host's config directory installed is not evidence that it
+ * owns this process.
  */
-export function resolveHostCacheDir(env = process.env, moduleUrl = import.meta.url) {
+export function resolveHostCacheDir(env = process.env, moduleUrl = import.meta.url, processIdentity = {}) {
     const mimoHome = env.MIMOCODE_HOME;
     if (mimoHome && mimoHome.length > 0) {
         return path.join(mimoHome, "cache");
@@ -74,12 +111,17 @@ export function resolveHostCacheDir(env = process.env, moduleUrl = import.meta.u
         modulePath = undefined;
     }
     if (modulePath) {
-        for (const host of ["mimocode", "kilo", "opencode"]) {
+        for (const host of HOST_CACHE_DIRS) {
             const root = path.resolve(cacheHome, host);
             if (modulePath === root || modulePath.startsWith(`${root}${path.sep}`))
                 return root;
         }
     }
+    // Source checkout: the module path can't name the host, but the binary that
+    // loaded us can (running as `mimo` / `kilocode` / `opencode`).
+    const host = hostCacheDirFromProcess(processIdentity.argv ?? process.argv, processIdentity.execPath ?? process.execPath);
+    if (host)
+        return path.join(cacheHome, host);
     return path.join(cacheHome, "opencode");
 }
 /**

package/dist/language-model.d.ts

@@ -85,7 +85,7 @@ export declare function buildOpenCodeInteractionGuidance(tools: OpencodeToolDef[
 export declare function estimateTokens(chars: number): number;
 /** Estimate current-request prompt tokens from the complete serialized V3 prompt. */
 export declare function estimatePromptTokens(prompt: LanguageModelV3CallOptions["prompt"]): number;
-/** Preserve cumulative Cursor counters as diagnostics, never as AI SDK request usage. */
+/** Preserve exact Cursor counters as diagnostics when they are cumulative across a multi-step Run. */
 export declare function cursorTurnEndedProviderMetadata(te: Record<string, unknown>): {
     cursor: {
         usageVersion: number;

package/dist/language-model.js

@@ -6,7 +6,7 @@ import { trace, traceRequestContextPaths } from "./debug.js";
 import { buildRunRequest, buildHeartbeat } from "./protocol/request.js";
 import { decodeFramePayload } from "./protocol/framing.js";
 import { debugWalkTurnEnded, decodeMessage } from "./protocol/messages.js";
-import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, classifyMissingReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, remapEditToolsForCatalog, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, } from "./protocol/tools.js";
+import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, classifyMissingReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, remapCorrelatedEditWriteForCatalog, remapEditToolsForCatalog, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, } from "./protocol/tools.js";
 import { describeCursorExecVariant } from "./protocol/exec-variants.js";
 import { advertisedToolNamesFromDescriptors, extractExecDisplayCallId, extractProtobufSubmessage, listProtobufFieldNumbers, parseDisplayToolCall, resolveBridgedOpenCodeToolCall, } from "./protocol/tool-call-bridge.js";
 import { handleKvServerMessage } from "./protocol/kv.js";
@@ -464,13 +464,19 @@ export async function pumpWithRecovery(input) {
             const delayMs = retryDelayMs(failure, attempt + 1, retryPolicy);
             trace(`Run retry backoff: attempt=${attempt + 1}/${maxRecoveries} delayMs=${delayMs}`);
             await sleepForRetry(delayMs, input.abortSignal);
-            session = await input.recover(checkpoint
+            const recovery = checkpoint
                 ? {
                     kind: "resume",
                     conversationId: pumpedSession.conversationId,
                     checkpoint: Uint8Array.from(checkpoint),
                 }
-                : { kind: "rebase" });
+                : { kind: "rebase" };
+            session = await input.recover(recovery);
+            if (recovery.kind === "resume") {
+                session.hadToolCallBoundary = pumpedSession.hadToolCallBoundary;
+                session.usageEstimate = { ...pumpedSession.usageEstimate };
+                session.editToolCalls = new Map(pumpedSession.editToolCalls);
+            }
             input.onSession?.(session);
         }
         finally {
@@ -693,6 +699,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         frames: stream.frames()[Symbol.asyncIterator](),
         pending: new Map(),
         displayToolCalls: new Map(),
+        editToolCalls: new Map(),
         nextBridgedExecId: 900_000,
         blobs: new Map(),
         toolDescriptors,
@@ -1145,8 +1152,12 @@ export async function pump(session, controller, ids, abortSignal) {
     };
     const emitFinish = (te, reason) => {
         closeOpenSpans();
-        if (te) {
-            // Authoritative TurnEnded counts — replace the running estimate.
+        // TurnEnded is request-local only when this Run did not previously stop at
+        // 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;
+        if (te && !cumulativeTurnEnded) {
             session.usageEstimate = {
                 inputTokens: turnEndedCounter(te, "input_tokens"),
                 outputTokens: turnEndedCounter(te, "output_tokens"),
@@ -1156,9 +1167,11 @@ export async function pump(session, controller, ids, abortSignal) {
             };
         }
         const est = session.usageEstimate;
-        const usage = te
+        const usage = te && !cumulativeTurnEnded
             ? buildLanguageModelV3UsageFromTurnEnded(te)
             : buildLanguageModelV3UsageFromEstimate(est, promptTokens, requestUsage.outputChars, estimateTokens);
+        if (!te)
+            session.hadToolCallBoundary = true;
         const providerMetadata = te ? cursorTurnEndedProviderMetadata(te) : undefined;
         const reasonLabel = typeof reason === "object" && reason && "unified" in reason
             ? String(reason.unified ?? "unknown")
@@ -1169,9 +1182,11 @@ export async function pump(session, controller, ids, abortSignal) {
             `v3In=${inTotal} v3Out=${outTotal} ` +
             `v3CacheRead=${usage.inputTokens?.cacheRead ?? 0} v3CacheWrite=${usage.inputTokens?.cacheWrite ?? 0} ` +
             `v3Reasoning=${usage.outputTokens?.reasoning ?? 0} ` +
-            `rawIn=${est.inputTokens} rawOut=${est.outputTokens} ` +
-            `rawCacheRead=${est.cacheRead} rawCacheWrite=${est.cacheWrite} ` +
-            `source=${te ? "turn_ended" : "estimate"}`);
+            `rawIn=${te ? turnEndedCounter(te, "input_tokens") : est.inputTokens} ` +
+            `rawOut=${te ? turnEndedCounter(te, "output_tokens") : est.outputTokens} ` +
+            `rawCacheRead=${te ? turnEndedCounter(te, "cache_read") : est.cacheRead} ` +
+            `rawCacheWrite=${te ? turnEndedCounter(te, "cache_write") : est.cacheWrite} ` +
+            `source=${te ? (cumulativeTurnEnded ? "estimate-cumulative-turn-ended" : "turn_ended") : "estimate"}`);
         safeEnqueue({
             type: "finish",
             usage,
@@ -1327,6 +1342,15 @@ export async function pump(session, controller, ids, abortSignal) {
                 if (callId && toolCall) {
                     session.displayToolCalls.set(callId, toolCall);
                     const variant = Object.keys(toolCall).find((k) => k.endsWith("_tool_call")) ?? "?";
+                    const display = parseDisplayToolCall(callId, toolCall);
+                    const editPath = display?.variant === "edit_tool_call"
+                        && typeof display.args.path === "string"
+                        ? display.args.path
+                        : undefined;
+                    if (editPath) {
+                        const editToolCalls = session.editToolCalls ?? (session.editToolCalls = new Map());
+                        editToolCalls.set(callId, { path: editPath });
+                    }
                     const callIdLog = callId.replace(/\r?\n/g, "\\n");
                     let wireFields = "";
                     if (variant === "?") {
@@ -1341,6 +1365,8 @@ export async function pump(session, controller, ids, abortSignal) {
             else if (iu?.tool_call_completed) {
                 const completed = iu.tool_call_completed;
                 const callId = typeof completed.call_id === "string" ? completed.call_id : "";
+                if (callId)
+                    session.editToolCalls?.delete(callId);
                 // If exec already claimed this call_id, display map entry is gone — skip.
                 if (!callId || !session.displayToolCalls.has(callId)) {
                     if (callId) {
@@ -1436,6 +1462,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 }
                 else {
                     replaySafety.markBarrier("non-control-exec");
+                    const displayCallId = extractExecDisplayCallId(esm);
                     const parsed = parseExecServerMessage(esm);
                     if (parsed) {
                         const executableToolName = resolveCustomWebToolAlias(parsed.toolName, session.toolAliases);
@@ -1444,12 +1471,24 @@ export async function pump(session, controller, ids, abortSignal) {
                             parsed.toolName = executableToolName;
                         }
                         remapNativeSubagentForCatalog(parsed, advertisedToolNameSet, session.subagentCatalog);
+                        const editCall = displayCallId
+                            ? session.editToolCalls?.get(displayCallId)
+                            : undefined;
+                        if (editCall) {
+                            const remapped = remapCorrelatedEditWriteForCatalog(parsed, advertisedToolNameSet, editCall.path, workspaceRootFromRequestContext(session.requestContext));
+                            if (parsed.resultField === "write_result" && displayCallId) {
+                                session.editToolCalls?.delete(displayCallId);
+                            }
+                            if (remapped) {
+                                trace(`exec: preserved edit intent callId=${displayCallId} ` +
+                                    `path=${JSON.stringify(editCall.path)}`);
+                            }
+                        }
                         // Hosts that advertise `apply_patch` in place of `edit`/`write` (see
                         // protocol/apply-patch.ts) still receive Cursor's native write/edit
                         // exec requests. Translate before the unavailable-tool check below.
                         remapEditToolsForCatalog(parsed, advertisedToolNameSet, workspaceRootFromRequestContext(session.requestContext));
                     }
-                    const displayCallId = extractExecDisplayCallId(esm);
                     trace(`exec: id=${parsed?.id} variant=${parsed ? Object.keys(parsed).join(",") : "none"} toolName=${parsed?.toolName} resultField=${parsed?.resultField}`);
                     if (parsed) {
                         if (parsed.localError) {
@@ -1770,7 +1809,7 @@ export function estimatePromptTokens(prompt) {
         .join("\n");
     return estimateTokens(serializedContent.length);
 }
-/** Preserve cumulative Cursor counters as diagnostics, never as AI SDK request usage. */
+/** Preserve exact Cursor counters as diagnostics when they are cumulative across a multi-step Run. */
 export function cursorTurnEndedProviderMetadata(te) {
     return {
         cursor: {

package/dist/protocol/tools.d.ts

@@ -87,6 +87,14 @@ export declare function resolveCursorSubagentType(subagentType: string, catalog?
 export declare function mapCursorSubagentTypeToOpenCode(subagentType: string): string;
 /** Resolve a native Cursor subagent request to this turn's executor and catalog. */
 export declare function remapNativeSubagentForCatalog(parsed: ParsedExecRequest, advertisedToolNames: Iterable<string>, catalog?: HostSubagentCatalog): void;
+/**
+ * Preserve a legacy Cursor edit's intent when its internal executor follows
+ * `edit_tool_call` with a whole-file `write_args` request.
+ *
+ * The result field intentionally remains `write_result`: that is the response
+ * Cursor is awaiting even though OpenCode executes the mutation via `edit`.
+ */
+export declare function remapCorrelatedEditWriteForCatalog(parsed: ParsedExecRequest, advertisedToolNames: Iterable<string>, editPath: string, workspaceRoot?: string): boolean;
 /**
  * Express a native Cursor write/edit as `apply_patch` when the host swapped the
  * edit-tool family out from under us.

package/dist/protocol/tools.js

@@ -483,6 +483,125 @@ export function remapNativeSubagentForCatalog(parsed, advertisedToolNames, catal
 }
 /** Matches Cursor's own pre-write read threshold (`local-exec` 52428800). */
 const MAX_EDIT_SOURCE_BYTES = 50 * 1024 * 1024;
+/** Return the number of non-overlapping occurrences, stopping after ambiguity. */
+function replacementOccurrenceCount(source, needle) {
+    if (!needle)
+        return 0;
+    const first = source.indexOf(needle);
+    if (first === -1)
+        return 0;
+    return source.indexOf(needle, first + needle.length) === -1 ? 1 : 2;
+}
+function previousLineStart(source, start) {
+    if (start <= 0)
+        return 0;
+    const before = source[start - 1] === "\n" ? start - 2 : start - 1;
+    return source.lastIndexOf("\n", before) + 1;
+}
+function followingLineEnd(source, end) {
+    if (end >= source.length)
+        return source.length;
+    const newline = source.indexOf("\n", end);
+    return newline === -1 ? source.length : newline + 1;
+}
+/**
+ * Collapse a whole-file replacement into one unique, line-bounded substring
+ * edit. Cursor's legacy edit executor computes a complete new file internally;
+ * OpenCode's `edit` tool instead wants old/new substrings.
+ */
+function planWholeFileEdit(source, target) {
+    if (!source || source === target)
+        return undefined;
+    let prefix = 0;
+    const shared = Math.min(source.length, target.length);
+    while (prefix < shared && source[prefix] === target[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < source.length - prefix
+        && suffix < target.length - prefix
+        && source[source.length - suffix - 1] === target[target.length - suffix - 1])
+        suffix++;
+    const sourceChangeEnd = source.length - suffix;
+    const targetChangeEnd = target.length - suffix;
+    let start = prefix === 0 ? 0 : source.lastIndexOf("\n", prefix - 1) + 1;
+    let end = sourceChangeEnd >= source.length
+        ? source.length
+        : followingLineEnd(source, sourceChangeEnd);
+    // A pure insertion can initially select no source text. Include an adjacent
+    // line because OpenCode edit deliberately rejects an empty oldString.
+    if (start === end) {
+        if (start > 0)
+            start = previousLineStart(source, start);
+        else
+            end = followingLineEnd(source, end);
+    }
+    const replacement = () => ({
+        oldString: source.slice(start, end),
+        newString: source.slice(start, prefix)
+            + target.slice(prefix, targetChangeEnd)
+            + source.slice(sourceChangeEnd, end),
+    });
+    let result = replacement();
+    while (replacementOccurrenceCount(source, result.oldString) !== 1) {
+        const priorStart = start;
+        const priorEnd = end;
+        if (start > 0)
+            start = previousLineStart(source, start);
+        if (end < source.length)
+            end = followingLineEnd(source, end);
+        if (start === priorStart && end === priorEnd)
+            return undefined;
+        result = replacement();
+    }
+    return result;
+}
+/**
+ * Preserve a legacy Cursor edit's intent when its internal executor follows
+ * `edit_tool_call` with a whole-file `write_args` request.
+ *
+ * The result field intentionally remains `write_result`: that is the response
+ * Cursor is awaiting even though OpenCode executes the mutation via `edit`.
+ */
+export function remapCorrelatedEditWriteForCatalog(parsed, advertisedToolNames, editPath, workspaceRoot) {
+    if (parsed.resultField !== "write_result" || parsed.toolName !== "write")
+        return false;
+    const advertised = new Set(advertisedToolNames);
+    if (!advertised.has("edit") && !advertised.has(APPLY_PATCH_TOOL))
+        return false;
+    const filePath = str(parsed.args.filePath);
+    const content = stringValue(parsed.args.content);
+    if (!filePath || content === undefined || !editPath)
+        return false;
+    const root = workspaceRoot ?? process.cwd();
+    const absolute = path.resolve(root, filePath);
+    if (absolute !== path.resolve(root, editPath))
+        return false;
+    let source;
+    try {
+        const stat = fs.statSync(absolute);
+        if (!stat.isFile() || stat.size > MAX_EDIT_SOURCE_BYTES)
+            return false;
+        if (Buffer.byteLength(content, "utf8") > MAX_EDIT_SOURCE_BYTES)
+            return false;
+        source = fs.readFileSync(absolute, "utf8");
+    }
+    catch {
+        // Missing targets are creations and must stay writes. Other read failures
+        // also fall back to the original host permission path without guessing.
+        return false;
+    }
+    const replacement = planWholeFileEdit(source, content);
+    if (!replacement)
+        return false;
+    parsed.toolName = "edit";
+    parsed.args = {
+        filePath,
+        oldString: replacement.oldString,
+        newString: replacement.newString,
+    };
+    parsed.resultMetadata = { ...parsed.resultMetadata, path: filePath };
+    return true;
+}
 /**
  * Express a native Cursor write/edit as `apply_patch` when the host swapped the
  * edit-tool family out from under us.
@@ -1202,9 +1321,9 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
             // Cursor's native read_args lands here; `mcp_args` reads land in
             // mcp_result. Live captures show gpt-5.4-mini and grok-4.5 both use the
             // native channel, so this is the path that matters in practice.
-            const content = unwrapReadOutput(output);
             const statPath = extractPathTag(output) ?? readPath;
             const outputMetadata = parseOpenCodeReadMetadata(output);
+            const content = restoreCompleteReadTerminator(unwrapReadOutput(output), statPath, outputMetadata, resultMetadata, resultRoot);
             const totalLines = outputMetadata.totalLines ?? readFileLineCount(statPath) ?? countLines(content);
             const rangeApplied = readRangeApplied(resultMetadata, totalLines);
             // `truncated` alone is not enough: it is set here, and models still assert
@@ -1452,6 +1571,53 @@ function parseOpenCodeReadMetadata(output) {
         return { totalLines: Number(complete[1]) };
     return {};
 }
+/**
+ * OpenCode's numbered read envelope cannot represent the terminator after the
+ * final line. Cursor's legacy edit executor performs exact replacement against
+ * this content, so dropping a real LF/CRLF makes otherwise-valid edits fail and
+ * encourages a whole-file rewrite. Restore only that final terminator for an
+ * unbounded, confirmed-complete read; paged/capped reads stay untouched.
+ */
+function restoreCompleteReadTerminator(content, readPath, metadata, resultMetadata, workspaceRoot) {
+    if (!readPath
+        || metadata.totalLines === undefined
+        || metadata.startLine !== undefined
+        || metadata.endLine !== undefined
+        || num(resultMetadata?.offset) !== undefined
+        || num(resultMetadata?.limit) !== undefined
+        || content.endsWith("\n"))
+        return content;
+    const absolute = path.isAbsolute(readPath)
+        ? readPath
+        : path.resolve(workspaceRoot ?? process.cwd(), readPath);
+    let fd;
+    try {
+        fd = fs.openSync(absolute, "r");
+        const size = fs.fstatSync(fd).size;
+        if (size === 0)
+            return content;
+        const tail = Buffer.alloc(Math.min(2, size));
+        fs.readSync(fd, tail, 0, tail.length, size - tail.length);
+        if (tail.length >= 2 && tail[tail.length - 2] === 0x0d && tail[tail.length - 1] === 0x0a) {
+            return `${content}\r\n`;
+        }
+        if (tail[tail.length - 1] === 0x0a)
+            return `${content}\n`;
+    }
+    catch {
+        // The host read result remains authoritative when the local path cannot be
+        // inspected (deleted/raced/permission changed after the tool completed).
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* already closed */ }
+        }
+    }
+    return content;
+}
 /**
  * OpenCode's `read` caps output at 50 KB (`tool/read.ts` MAX_BYTES = 50 * 1024)
  * and cuts on a whole-line boundary, then appends

package/dist/session.d.ts

@@ -112,6 +112,14 @@ export type CursorSession = {
      * or when we bridge the completed display call into an OpenCode tool-call.
      */
     displayToolCalls: Map<string, Record<string, unknown>>;
+    /**
+     * Legacy edit calls whose authoritative exec path is still in progress.
+     * Cursor implements these as read -> whole-file write; retaining the path
+     * lets the pump expose the final mutation to OpenCode as a targeted edit.
+     */
+    editToolCalls?: Map<string, {
+        path: string;
+    }>;
     /** Monotonic synthetic exec ids for bridged (display-only) OpenCode tool calls. */
     nextBridgedExecId: number;
     /** KV blob store: blob_id (hex) → data, for Cursor's out-of-band payload channel. */
@@ -132,8 +140,8 @@ export type CursorSession = {
     allowTools: boolean;
     /**
      * Best-effort token usage for this held-open Run. Updated from text/tool
-     * activity and replaced by TurnEnded when the turn completes. Emitted on
-     * tool-calls finishes so OpenCode does not store all-zero usage mid-loop.
+     * activity and replaced by TurnEnded only for a single-step Run. Emitted on
+     * tool-call finishes so OpenCode does not store all-zero usage mid-loop.
      */
     usageEstimate: {
         inputTokens: number;
@@ -142,6 +150,13 @@ export type CursorSession = {
         cacheWrite: number;
         reasoningTokens: number;
     };
+    /**
+     * True after this held Run has already crossed an OpenCode tool-call
+     * boundary. Cursor's eventual TurnEnded counters then cover the whole Run,
+     * not only the final doStream request, so they cannot be used as that
+     * request's context usage.
+     */
+    hadToolCallBoundary?: boolean;
     /**
      * True while a doStream pull() is actively reading this session's frames.
      * Prevents a late cancel/abort from a prior ReadableStream from destroying

package/dist/usage.d.ts

@@ -2,8 +2,9 @@ import type { LanguageModelV3Usage } from "@ai-sdk/provider";
 /** Non-negative integer counter from a Cursor `turn_ended` field. */
 export declare function turnEndedCounter(te: Record<string, unknown>, key: string): number;
 /**
- * Map authoritative Cursor TurnEnded counters to AI SDK V3 usage (Kilo/OpenCode
- * flatten via input total = noCache + cacheRead + cacheWrite).
+ * Map request-local Cursor TurnEnded counters to AI SDK V3 usage (Kilo/OpenCode
+ * flatten via input total = noCache + cacheRead + cacheWrite). Only use this
+ * for a Run with no prior tool boundary; multi-step TurnEnded is cumulative.
  *
  * Contract: `input_tokens` is non-cached input; cache fields are separate.
  * Cursor's agent wire currently sends `cache_write=0` even when later turns
@@ -18,7 +19,15 @@ export type CursorUsageEstimate = {
     cacheWrite: number;
     reasoningTokens: number;
 };
-/** Mid-turn finish (e.g. tool-calls) before `turn_ended` — keep non-zero estimates. */
+/**
+ * Request-local usage for a held Cursor Run.
+ *
+ * `est.inputTokens` tracks the seed plus delivered tool results, while
+ * `est.outputTokens` accumulates model output across earlier tool boundaries.
+ * Move prior output into the current input estimate and report only this
+ * doStream request's output. Cache counters are intentionally absent: the
+ * only counters Cursor exposes at TurnEnded are cumulative for the whole Run.
+ */
 export declare function buildLanguageModelV3UsageFromEstimate(est: CursorUsageEstimate, promptTokens: number, outputChars: number, estimateCharsToTokens: (chars: number) => number): LanguageModelV3Usage;
 /** Mirror Kilo `Session.getUsage` / AI SDK flat fields from V3 nested usage. */
 export declare function kiloShapedUsageFromV3(usage: LanguageModelV3Usage): {

package/dist/usage.js

@@ -6,8 +6,9 @@ export function turnEndedCounter(te, key) {
         : 0;
 }
 /**
- * Map authoritative Cursor TurnEnded counters to AI SDK V3 usage (Kilo/OpenCode
- * flatten via input total = noCache + cacheRead + cacheWrite).
+ * Map request-local Cursor TurnEnded counters to AI SDK V3 usage (Kilo/OpenCode
+ * flatten via input total = noCache + cacheRead + cacheWrite). Only use this
+ * for a Run with no prior tool boundary; multi-step TurnEnded is cumulative.
  *
  * Contract: `input_tokens` is non-cached input; cache fields are separate.
  * Cursor's agent wire currently sends `cache_write=0` even when later turns
@@ -34,27 +35,30 @@ export function buildLanguageModelV3UsageFromTurnEnded(te) {
         },
     };
 }
-/** Mid-turn finish (e.g. tool-calls) before `turn_ended` — keep non-zero estimates. */
+/**
+ * Request-local usage for a held Cursor Run.
+ *
+ * `est.inputTokens` tracks the seed plus delivered tool results, while
+ * `est.outputTokens` accumulates model output across earlier tool boundaries.
+ * Move prior output into the current input estimate and report only this
+ * doStream request's output. Cache counters are intentionally absent: the
+ * only counters Cursor exposes at TurnEnded are cumulative for the whole Run.
+ */
 export function buildLanguageModelV3UsageFromEstimate(est, promptTokens, outputChars, estimateCharsToTokens) {
-    const hasInputBreakdown = est.cacheRead > 0 || est.cacheWrite > 0 || est.inputTokens > 0;
-    const inputNoCache = hasInputBreakdown ? est.inputTokens : promptTokens;
-    const cacheRead = est.cacheRead;
-    const cacheWrite = est.cacheWrite;
-    const outputFromChars = estimateCharsToTokens(outputChars);
-    const outputText = est.outputTokens > 0 ? est.outputTokens : outputFromChars;
-    const reasoning = est.reasoningTokens;
-    const outputTotal = outputText + reasoning;
+    const outputText = estimateCharsToTokens(outputChars);
+    const priorOutput = Math.max(0, est.outputTokens - outputText);
+    const inputNoCache = Math.max(promptTokens, est.inputTokens + priorOutput);
     return {
         inputTokens: {
-            total: inputNoCache + cacheRead + cacheWrite,
+            total: inputNoCache,
             noCache: inputNoCache,
-            cacheRead,
-            cacheWrite,
+            cacheRead: 0,
+            cacheWrite: 0,
         },
         outputTokens: {
-            total: outputTotal,
+            total: outputText,
             text: outputText,
-            reasoning: reasoning > 0 ? reasoning : undefined,
+            reasoning: undefined,
         },
     };
 }

package/package.json

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