cursor-opencode-provider 0.3.0 → 0.3.2

package/dist/pricing.js

@@ -0,0 +1,127 @@
+/**
+ * Cursor model token pricing for OpenCode cost reporting.
+ *
+ * Rates come from Cursor's public docs (Other Models pool = provider API price).
+ * Generated data lives in `pricing-data.ts`; regenerate with
+ * `bun run generate:pricing`. Unknown / unpublished models get no `cost`.
+ */
+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"];
+const UNPRICED = new Set(CURSOR_UNPRICED_MODEL_IDS);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonNegativeFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function collectCostValidationErrors(value, path, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${path} must be an object`);
+        return;
+    }
+    if (!isNonNegativeFiniteNumber(value.input)) {
+        errors.push(`${path}.input must be a non-negative finite number`);
+    }
+    if (!isNonNegativeFiniteNumber(value.output)) {
+        errors.push(`${path}.output must be a non-negative finite number`);
+    }
+    if (value.cache_read !== undefined && !isNonNegativeFiniteNumber(value.cache_read)) {
+        errors.push(`${path}.cache_read must be a non-negative finite number`);
+    }
+    if (value.cache_write !== undefined && !isNonNegativeFiniteNumber(value.cache_write)) {
+        errors.push(`${path}.cache_write must be a non-negative finite number`);
+    }
+    if (value.context_over_200k !== undefined) {
+        collectCostValidationErrors(value.context_over_200k, `${path}.context_over_200k`, errors);
+    }
+}
+export function validateOpenCodeModelCost(value, path = "cost") {
+    const errors = [];
+    collectCostValidationErrors(value, path, errors);
+    return { valid: errors.length === 0, errors };
+}
+export function isOpenCodeModelCost(value) {
+    return validateOpenCodeModelCost(value).valid;
+}
+/** Strip synthetic OpenCode long-context suffix (`…-1m`, `…-1m-2`, …). */
+export function wireModelIdForPricing(modelId) {
+    const match = /^(.*)-1m(?:-(\d+))?$/.exec(modelId);
+    if (!match)
+        return { baseId: modelId, longContextEntry: false };
+    return { baseId: match[1], longContextEntry: true };
+}
+function asMutableCost(value) {
+    const copy = { input: value.input, output: value.output };
+    if (value.cache_read !== undefined)
+        copy.cache_read = value.cache_read;
+    if (value.cache_write !== undefined)
+        copy.cache_write = value.cache_write;
+    if (value.context_over_200k) {
+        copy.context_over_200k = asMutableCost(value.context_over_200k);
+    }
+    return copy;
+}
+/**
+ * Look up classic OpenCode cost for a catalog / wire model id.
+ * Synthetic `-1m` entries retain both base and documented long-context rates.
+ */
+export function getCursorModelCost(modelId) {
+    const { baseId } = wireModelIdForPricing(modelId);
+    const found = CURSOR_MODEL_COSTS[baseId];
+    if (!found)
+        return undefined;
+    return asMutableCost(found);
+}
+export function applyCursorModelCost(modelId, entry) {
+    const modelCost = getCursorModelCost(modelId);
+    if (!modelCost)
+        return entry;
+    return { ...entry, cost: modelCost };
+}
+/** Convert classic cost → OpenCode 2.0 `Model.Info.cost` array. */
+export function toOpenCode2Costs(cost) {
+    if (!cost)
+        return [];
+    const out = [
+        {
+            input: cost.input,
+            output: cost.output,
+            cache: {
+                read: cost.cache_read ?? 0,
+                write: cost.cache_write ?? 0,
+            },
+        },
+    ];
+    if (cost.context_over_200k) {
+        out.push({
+            tier: { type: "context", size: 200_000 },
+            input: cost.context_over_200k.input,
+            output: cost.context_over_200k.output,
+            cache: {
+                read: cost.context_over_200k.cache_read ?? 0,
+                write: cost.context_over_200k.cache_write ?? 0,
+            },
+        });
+    }
+    return out;
+}
+/**
+ * Coverage helper for CI / maintainer checks.
+ * Intentionally unpriced first-party ids are counted as priced (covered).
+ */
+export function checkCursorPricingCoverage(modelIds) {
+    const priced = [];
+    const missing = [];
+    for (const modelId of modelIds) {
+        const { baseId } = wireModelIdForPricing(modelId);
+        if (UNPRICED.has(baseId) || getCursorModelCost(modelId))
+            priced.push(modelId);
+        else
+            missing.push(modelId);
+    }
+    return { priced, missing };
+}

package/dist/protocol/apply-patch.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Synthesis of OpenCode `apply_patch` envelopes from Cursor's native write/edit
+ * exec requests.
+ *
+ * ## Why this exists
+ *
+ * OpenCode 1.x does not merely *add* `apply_patch` for GPT models — it removes
+ * `edit` and `write` from the catalog in exchange. From
+ * `packages/opencode/src/tool/registry.ts` (`ToolRegistry.tools`):
+ *
+ * ```ts
+ * // use apply tool in same format as codex
+ * const usePatch =
+ *   input.modelID.includes("gpt-") && !input.modelID.includes("oss") && !input.modelID.includes("gpt-4")
+ * if (tool.id === ApplyPatchTool.id) return usePatch
+ * if (tool.id === EditTool.id || tool.id === WriteTool.id) return !usePatch
+ * ```
+ *
+ * The predicate runs on the *API* model id, so every Cursor `gpt-5*` model
+ * matches (and, as a quirk of substring matching, `gpt-3.5-*` does too while
+ * `gpt-4o` does not).
+ *
+ * Upstream context, in case this ever needs revisiting:
+ *
+ * - Introduced by opencode PR #9127 ("apply_patch tool for openai models"). The
+ *   intent is to hand GPT/Codex models the tool surface they were post-trained
+ *   on; the same commit tells the codex system prompt to prefer `apply_patch`.
+ * - The *exclusivity* is deliberate. On opencode issue #34491 a maintainer
+ *   describes the gate as a "band-aid", "intentionally minimal", whose purpose
+ *   is that "GPT no longer receives edit + write + apply_patch simultaneously",
+ *   and notes that a plugin-side opt-out "isn't feasible today".
+ * - opencode issue #19942 reported exactly this hazard — model-conditional tool
+ *   substitution makes model-agnostic integrations impossible — and was closed
+ *   `not_planned` by a stale bot.
+ * - opencode issue #35408 (open, milestone 2.0) proposes a
+ *   `ctx.session.context(...)` hook exposing a mutable tool roster, and lists
+ *   "Select `apply_patch` versus `edit` + `write`" as work to move out of the
+ *   registry. Once that lands, a host-side opt-out replaces this shim.
+ * - OpenCode 2.0 (`packages/core`) has **no** such gate: `apply_patch`, `edit`
+ *   and `write` are all registered unconditionally in `tool/builtins.ts`. This
+ *   translation is therefore 1.x-only in practice, but it is keyed off the
+ *   advertised set rather than a version check, so it simply never fires on 2.0.
+ *
+ * ## Why translation, not advertisement
+ *
+ * `toolsToDescriptors` forwards every advertised host tool to Cursor verbatim,
+ * so `opencode-apply_patch` already appears in Cursor's catalog whenever
+ * OpenCode advertises it, and an `mcp_args` call naming it already executes.
+ * What breaks is Cursor's *native* write/edit channel (`write_args`,
+ * `pi_edit_args`), which this provider resolves to the fixed host names
+ * `write`/`edit`.
+ *
+ * Translating on our side is the only option: Cursor's agent protocol has no
+ * patch-format edit tool at all (its `ToolCall` oneof offers whole-file
+ * `edit_tool_call`/`write_args` and substring `pi_edit_tool_call`/`pi_edit_args`;
+ * `apply_agent_diff_tool_call` is unrelated — it applies a cloud agent's diff by
+ * `agent_id`). Cursor's CLI also contains no model-conditional branching
+ * whatsoever, and `ModelDetails` carries no tool-capability flags, so the same
+ * native requests arrive for every model. Those names are absent from
+ * the catalog, so the request is refused before it reaches OpenCode.
+ *
+ * ## Format notes (verified against `packages/opencode/src/patch/index.ts`)
+ *
+ * - `*** Add File:` **overwrites an existing file** — the tool's `add` case uses
+ *   `oldContent = ""` and never stats the target (upstream test: "adds file
+ *   overwriting existing file"). A whole-file write therefore needs no diff and
+ *   no existence check.
+ * - An empty `@@` header is a valid chunk start: the parser stores
+ *   `change_context: contextLine || undefined`, and a missing context simply
+ *   means "match `old_lines` from the current scan position".
+ * - Every payload line is prefixed with `+`, `-`, or a space, and the parser
+ *   only breaks on *unprefixed* `***` / `@@`. Content lines that themselves
+ *   begin with `***` or `@@` therefore survive a round trip unharmed.
+ * - `Add File` content is rejoined with `\n` and normalized to exactly one
+ *   trailing newline. A write of content with no trailing newline gains one.
+ * - Update chunks match **whole lines** via `seekSequence`, unlike OpenCode
+ *   `edit`, which is substring-based. Substring edits must be expanded to line
+ *   boundaries before they can be expressed as a patch — see `planSubstringEdit`.
+ * - Renames are rejected by OpenCode 2.0's implementation ("apply_patch moves
+ *   are not supported yet"), so `*** Move to:` is never emitted here.
+ */
+export declare const APPLY_PATCH_TOOL = "apply_patch";
+/** One `@@` chunk: replace `oldLines` with `newLines`. */
+export type UpdateChunk = {
+    oldLines: string[];
+    newLines: string[];
+};
+/**
+ * Whole-file write as `*** Add File:`. Valid whether or not the target exists —
+ * OpenCode's add case overwrites unconditionally.
+ */
+export declare function buildAddFilePatch(filePath: string, content: string): string;
+/** Targeted replacement as `*** Update File:` with one `@@` chunk per change. */
+export declare function buildUpdateFilePatch(filePath: string, chunks: UpdateChunk[]): string;
+export type SubstringEditPlan = {
+    ok: true;
+    chunks: UpdateChunk[];
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Expand a substring replacement to the whole lines it touches, because
+ * `apply_patch` matches line sequences rather than substrings.
+ *
+ * Refuses rather than guessing: an absent match, or an ambiguous one without
+ * `replaceAll`, would otherwise be silently applied to the wrong region.
+ */
+export declare function planSubstringEdit(source: string, oldString: string, newString: string, replaceAll?: boolean): SubstringEditPlan;

package/dist/protocol/apply-patch.js

@@ -0,0 +1,163 @@
+/**
+ * Synthesis of OpenCode `apply_patch` envelopes from Cursor's native write/edit
+ * exec requests.
+ *
+ * ## Why this exists
+ *
+ * OpenCode 1.x does not merely *add* `apply_patch` for GPT models — it removes
+ * `edit` and `write` from the catalog in exchange. From
+ * `packages/opencode/src/tool/registry.ts` (`ToolRegistry.tools`):
+ *
+ * ```ts
+ * // use apply tool in same format as codex
+ * const usePatch =
+ *   input.modelID.includes("gpt-") && !input.modelID.includes("oss") && !input.modelID.includes("gpt-4")
+ * if (tool.id === ApplyPatchTool.id) return usePatch
+ * if (tool.id === EditTool.id || tool.id === WriteTool.id) return !usePatch
+ * ```
+ *
+ * The predicate runs on the *API* model id, so every Cursor `gpt-5*` model
+ * matches (and, as a quirk of substring matching, `gpt-3.5-*` does too while
+ * `gpt-4o` does not).
+ *
+ * Upstream context, in case this ever needs revisiting:
+ *
+ * - Introduced by opencode PR #9127 ("apply_patch tool for openai models"). The
+ *   intent is to hand GPT/Codex models the tool surface they were post-trained
+ *   on; the same commit tells the codex system prompt to prefer `apply_patch`.
+ * - The *exclusivity* is deliberate. On opencode issue #34491 a maintainer
+ *   describes the gate as a "band-aid", "intentionally minimal", whose purpose
+ *   is that "GPT no longer receives edit + write + apply_patch simultaneously",
+ *   and notes that a plugin-side opt-out "isn't feasible today".
+ * - opencode issue #19942 reported exactly this hazard — model-conditional tool
+ *   substitution makes model-agnostic integrations impossible — and was closed
+ *   `not_planned` by a stale bot.
+ * - opencode issue #35408 (open, milestone 2.0) proposes a
+ *   `ctx.session.context(...)` hook exposing a mutable tool roster, and lists
+ *   "Select `apply_patch` versus `edit` + `write`" as work to move out of the
+ *   registry. Once that lands, a host-side opt-out replaces this shim.
+ * - OpenCode 2.0 (`packages/core`) has **no** such gate: `apply_patch`, `edit`
+ *   and `write` are all registered unconditionally in `tool/builtins.ts`. This
+ *   translation is therefore 1.x-only in practice, but it is keyed off the
+ *   advertised set rather than a version check, so it simply never fires on 2.0.
+ *
+ * ## Why translation, not advertisement
+ *
+ * `toolsToDescriptors` forwards every advertised host tool to Cursor verbatim,
+ * so `opencode-apply_patch` already appears in Cursor's catalog whenever
+ * OpenCode advertises it, and an `mcp_args` call naming it already executes.
+ * What breaks is Cursor's *native* write/edit channel (`write_args`,
+ * `pi_edit_args`), which this provider resolves to the fixed host names
+ * `write`/`edit`.
+ *
+ * Translating on our side is the only option: Cursor's agent protocol has no
+ * patch-format edit tool at all (its `ToolCall` oneof offers whole-file
+ * `edit_tool_call`/`write_args` and substring `pi_edit_tool_call`/`pi_edit_args`;
+ * `apply_agent_diff_tool_call` is unrelated — it applies a cloud agent's diff by
+ * `agent_id`). Cursor's CLI also contains no model-conditional branching
+ * whatsoever, and `ModelDetails` carries no tool-capability flags, so the same
+ * native requests arrive for every model. Those names are absent from
+ * the catalog, so the request is refused before it reaches OpenCode.
+ *
+ * ## Format notes (verified against `packages/opencode/src/patch/index.ts`)
+ *
+ * - `*** Add File:` **overwrites an existing file** — the tool's `add` case uses
+ *   `oldContent = ""` and never stats the target (upstream test: "adds file
+ *   overwriting existing file"). A whole-file write therefore needs no diff and
+ *   no existence check.
+ * - An empty `@@` header is a valid chunk start: the parser stores
+ *   `change_context: contextLine || undefined`, and a missing context simply
+ *   means "match `old_lines` from the current scan position".
+ * - Every payload line is prefixed with `+`, `-`, or a space, and the parser
+ *   only breaks on *unprefixed* `***` / `@@`. Content lines that themselves
+ *   begin with `***` or `@@` therefore survive a round trip unharmed.
+ * - `Add File` content is rejoined with `\n` and normalized to exactly one
+ *   trailing newline. A write of content with no trailing newline gains one.
+ * - Update chunks match **whole lines** via `seekSequence`, unlike OpenCode
+ *   `edit`, which is substring-based. Substring edits must be expanded to line
+ *   boundaries before they can be expressed as a patch — see `planSubstringEdit`.
+ * - Renames are rejected by OpenCode 2.0's implementation ("apply_patch moves
+ *   are not supported yet"), so `*** Move to:` is never emitted here.
+ */
+export const APPLY_PATCH_TOOL = "apply_patch";
+const BEGIN = "*** Begin Patch";
+const END = "*** End Patch";
+/**
+ * Whole-file write as `*** Add File:`. Valid whether or not the target exists —
+ * OpenCode's add case overwrites unconditionally.
+ */
+export function buildAddFilePatch(filePath, content) {
+    const lines = splitLines(content);
+    return [BEGIN, `*** Add File: ${filePath}`, ...lines.map((line) => `+${line}`), END].join("\n");
+}
+/** Targeted replacement as `*** Update File:` with one `@@` chunk per change. */
+export function buildUpdateFilePatch(filePath, chunks) {
+    const body = [];
+    for (const chunk of chunks) {
+        body.push("@@");
+        for (const line of chunk.oldLines)
+            body.push(`-${line}`);
+        for (const line of chunk.newLines)
+            body.push(`+${line}`);
+    }
+    return [BEGIN, `*** Update File: ${filePath}`, ...body, END].join("\n");
+}
+/**
+ * Expand a substring replacement to the whole lines it touches, because
+ * `apply_patch` matches line sequences rather than substrings.
+ *
+ * Refuses rather than guessing: an absent match, or an ambiguous one without
+ * `replaceAll`, would otherwise be silently applied to the wrong region.
+ */
+export function planSubstringEdit(source, oldString, newString, replaceAll = false) {
+    if (oldString === "")
+        return { ok: false, reason: "the text to replace is empty" };
+    const offsets = [];
+    for (let at = source.indexOf(oldString); at !== -1; at = source.indexOf(oldString, at + oldString.length)) {
+        offsets.push(at);
+    }
+    if (offsets.length === 0)
+        return { ok: false, reason: "the text to replace was not found in the file" };
+    if (offsets.length > 1 && !replaceAll) {
+        return {
+            ok: false,
+            reason: `the text to replace appears ${offsets.length} times; it must be unique`,
+        };
+    }
+    const targets = replaceAll ? offsets : offsets.slice(0, 1);
+    const chunks = [];
+    let previousEnd = -1;
+    for (const offset of targets) {
+        const start = lineStart(source, offset);
+        const end = lineEnd(source, offset + oldString.length);
+        // Overlapping expansions would emit the same original lines twice, and the
+        // second chunk could never match after the first replaced them.
+        if (start < previousEnd) {
+            return { ok: false, reason: "overlapping replacements cannot be expressed as a patch" };
+        }
+        previousEnd = end;
+        const before = source.slice(start, offset);
+        const after = source.slice(offset + oldString.length, end);
+        chunks.push({
+            oldLines: splitLines(source.slice(start, end)),
+            newLines: splitLines(before + newString + after),
+        });
+    }
+    return { ok: true, chunks };
+}
+/**
+ * Split into patch payload lines. A trailing newline is dropped so it is not
+ * emitted as a spurious empty line — OpenCode re-adds exactly one on apply.
+ */
+function splitLines(text) {
+    const normalized = text.endsWith("\n") ? text.slice(0, -1) : text;
+    return normalized.split("\n");
+}
+function lineStart(source, offset) {
+    const at = source.lastIndexOf("\n", offset - 1);
+    return at === -1 ? 0 : at + 1;
+}
+function lineEnd(source, offset) {
+    const at = source.indexOf("\n", offset);
+    return at === -1 ? source.length : at;
+}

package/dist/protocol/messages.js

@@ -434,15 +434,22 @@ export function createMessageTypes() {
         { id: 1, name: "success", type: "GrepSuccess" },
         { id: 2, name: "error", type: "GrepError" },
     ], [{ name: "result", fields: ["success", "error"] }]);
+    // agent.v1.WriteArgs. Cursor's own LocalWriteExecutor reads `file_bytes`
+    // first and only falls back to `file_text`, so a write whose content arrives
+    // as bytes decodes to an empty string unless field 5 is declared here.
     addType(root, "WriteArgs", [
         { id: 1, name: "path", type: "string" },
         { id: 2, name: "file_text", type: "string" },
         { id: 3, name: "tool_call_id", type: "string" },
+        { id: 4, name: "return_file_content_after_write", type: "bool" },
+        { id: 5, name: "file_bytes", type: "bytes" },
+        { id: 6, name: "encoding_hint", type: "string" },
     ]);
     addType(root, "WriteSuccess", [
         { id: 1, name: "path", type: "string" },
         { id: 2, name: "lines_created", type: "int32" },
         { id: 3, name: "file_size", type: "int32" },
+        { id: 4, name: "file_content_after_write", type: "string" },
     ]);
     addType(root, "WriteError", [
         { id: 1, name: "path", type: "string" },
@@ -476,7 +483,26 @@ export function createMessageTypes() {
         { id: 2, name: "error", type: "PiWriteError" },
         { id: 3, name: "rejected", type: "PiWriteRejected" },
     ], [{ name: "result", fields: ["success", "error", "rejected"] }]);
-    addType(root, "PiOutputSuccess", [{ id: 1, name: "output", type: "string" }]);
+    // agent.v1.PiTruncation. Every Pi *ExecSuccess shares output(1)+truncation(2)
+    // and only diverges at field 3, so the shared PiOutputSuccess can carry it.
+    // Cursor's own CLI always reports truncation rather than silently shortening
+    // a payload; emitting this keeps a capped read distinguishable from a
+    // complete one.
+    addType(root, "PiTruncation", [
+        { id: 1, name: "truncated", type: "bool" },
+        { id: 2, name: "truncated_by", type: "string" },
+        { id: 3, name: "total_lines", type: "uint32" },
+        { id: 4, name: "output_lines", type: "uint32" },
+        { id: 5, name: "output_bytes", type: "uint32" },
+        { id: 6, name: "max_lines", type: "uint32" },
+        { id: 7, name: "max_bytes", type: "uint32" },
+        { id: 8, name: "first_line_exceeds_limit", type: "bool" },
+        { id: 9, name: "last_line_partial", type: "bool" },
+    ]);
+    addType(root, "PiOutputSuccess", [
+        { id: 1, name: "output", type: "string" },
+        { id: 2, name: "truncation", type: "PiTruncation" },
+    ]);
     addType(root, "PiExecError", [{ id: 1, name: "error", type: "string" }]);
     addType(root, "PiExecRejected", [{ id: 1, name: "reason", type: "string" }]);
     for (const resultType of [

package/dist/protocol/tools.d.ts

@@ -87,6 +87,22 @@ 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;
+/**
+ * Express a native Cursor write/edit as `apply_patch` when the host swapped the
+ * edit-tool family out from under us.
+ *
+ * OpenCode 1.x removes `edit` and `write` from the catalog for GPT models and
+ * advertises `apply_patch` in their place — see the module comment in
+ * `./apply-patch.ts` for the upstream reasoning and citations. Cursor keeps
+ * using its native write/edit exec channel regardless, so without this the
+ * request is refused as an unavailable tool and the model loses the ability to
+ * change files at all.
+ *
+ * Keyed purely off the advertised set: this is inert whenever the host offers
+ * `write`/`edit` normally, and equally inert when it offers neither those nor
+ * `apply_patch` (the caller's unavailable-tool rejection still applies).
+ */
+export declare function remapEditToolsForCatalog(parsed: ParsedExecRequest, advertisedToolNames: Iterable<string>, workspaceRoot?: string): void;
 export type ParsedExecRequest = {
     id: number;
     execId: string;