cursor-opencode-provider 0.3.2 → 0.4.1

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/shared.d.ts

@@ -10,7 +10,7 @@ export declare const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableMo
 export declare const SERVER_CONFIG_PATH = "/aiserver.v1.ServerConfigService/GetServerConfig";
 export declare const MODEL_CACHE_FILE = "cursor-models.json";
 /** Bumped when the on-disk model cache shape/semantics change (forces refetch). */
-export declare const MODEL_CACHE_SCHEMA_VERSION = 2;
+export declare const MODEL_CACHE_SCHEMA_VERSION = 3;
 export declare const MODEL_CACHE_TTL_MS = 86400000;
 export declare const VERSION_CACHE_FILE = "cursor-client-version.json";
 export declare const CONTENT_TYPE_CONNECT_PROTO = "application/connect+proto";

package/dist/shared.js

@@ -10,7 +10,7 @@ export const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
 export const SERVER_CONFIG_PATH = "/aiserver.v1.ServerConfigService/GetServerConfig";
 export const MODEL_CACHE_FILE = "cursor-models.json";
 /** Bumped when the on-disk model cache shape/semantics change (forces refetch). */
-export const MODEL_CACHE_SCHEMA_VERSION = 2;
+export const MODEL_CACHE_SCHEMA_VERSION = 3;
 export const MODEL_CACHE_TTL_MS = 86_400_000;
 export const VERSION_CACHE_FILE = "cursor-client-version.json";
 export const CONTENT_TYPE_CONNECT_PROTO = "application/connect+proto";

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.3.2",
+  "version": "0.4.1",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -43,6 +43,18 @@
     "./errors": {
       "types": "./dist/errors.d.ts",
       "import": "./dist/errors.js"
+    },
+    "./models": {
+      "types": "./dist/models.d.ts",
+      "import": "./dist/models.js"
+    },
+    "./pricing": {
+      "types": "./dist/pricing.d.ts",
+      "import": "./dist/pricing.js"
+    },
+    "./auth": {
+      "types": "./dist/auth.d.ts",
+      "import": "./dist/auth.js"
     }
   },
   "files": [
@@ -64,7 +76,7 @@
     "prepublishOnly": "bun run generate:pricing && bun run build"
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.14",
+    "@ai-sdk/provider": "3.0.15",
     "protobufjs": "^7.6.5"
   },
   "peerDependencies": {
@@ -77,8 +89,8 @@
     }
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.18.13",
-    "@opencode-ai/plugin-next": "npm:@opencode-ai/plugin@0.0.0-next-16281",
+    "@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/node": "^22.20.1",
     "typescript": "^5.9.3"