cursor-opencode-provider 0.6.6 → 0.6.8

package/README.md

@@ -419,7 +419,9 @@ OpenCode
 
 ### Injected system guidance
 
-The provider adds OpenCode-specific system guidance to normal tool-capable conversations, including tool availability, canonical workspace-path grounding, and preferring `edit` / `write` (or `apply_patch`, when the host advertises that instead) over shell-based file mutation when those tools are available. Compaction keeps its dedicated prompt unchanged.
+The provider adds OpenCode-specific system guidance to normal tool-capable conversations, including tool availability, canonical workspace-path grounding, preferring OpenCode `todowrite` / `todoread` over Cursor TodoWrite without inviting catalog-comparison narration, and preferring `edit` / `write` (or `apply_patch`, when the host advertises that instead) over shell-based file mutation when those tools are available. Compaction keeps its dedicated prompt unchanged.
+
+Native Cursor todo display updates (`update_todos_tool_call` / `read_todos_tool_call`) are mirrored into `todowrite` / `todoread` when those host tools are advertised. The provider retains the last known full list per OpenCode session — refreshed by bridged writes, direct host `todowrite` calls, and `todoread` results, surviving Run close, checkpoint resume, and later turns — so `merge: true` updates that omit Cursor's completed list still become a host replace-all snapshot (matched by id, then by content across id spaces). This snapshot is in-memory only and never enters the prompt, RequestContext, or persisted restart state, so Cursor's prompt-cache prefix is unaffected.
 
 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).
 
@@ -492,7 +494,7 @@ Project `instructions` may reference absolute or `~/` paths (OpenCode parity). S
 - **Cursor's checkpoint controls displayed totals** — live continuation captures show `TurnEnded` counters can decrease between turns and can represent aggregate model work rather than final context occupancy. When a checkpoint contains `ConversationStateStructure.token_details`, the provider makes AI SDK input + output equal Cursor's `used_tokens`; at `TurnEnded`, output/reasoning remain based on `TurnEnded`, while uncached/cache-read/cache-write input are proportionally normalized to the remaining context input. OpenCode TUI/GUI replace each assistant message's tokens (TUI requires `tokens.output > 0`) and add cost per step, so mid-turn tool boundaries emit the last-known occupancy snapshot rather than a delta or a billed zero. Those snapshots set `output=1` so the footer updates and `providerMetadata.copilot.totalNanoAiu: 0` so OpenCode's getUsage reports $0 instead of charging occupancy as a new prompt. A Run without fresh token details retains the previous checkpoint snapshot and marks `providerMetadata.cursor.context` as `source: "checkpoint-previous-turn", stale: true`. If no checkpoint has ever supplied token details, standard usage is zero and context metadata is absent, so `TurnEnded` is never misrepresented as occupancy; its exact values remain under `providerMetadata.cursor.*Raw`. The full known snapshot includes `usedTokens`, `maxTokens`, percentage, category breakdown, source, and staleness. Cursor 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). Expensive workspace state (rules, environment, repository, git, and layout) is frozen per Cursor conversation and persisted for restart recovery. Tools/MCP descriptors, skills, subagents, and plugin metadata are rediscovered and overlaid each Run; unchanged overlays reuse byte-identical encoded context, while enabling/disabling a capability becomes visible on the next turn. Concurrent first Runs share one base build, and compaction/reset clears it. 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 variants are soft-denied on the held Run with a populated typed error/`rejected`/`allowlisted:false` result (or `throw` when the CLI has no typed error shape) so the turn continues; unknown future request fields still fail the Run explicitly rather than receiving a guessed response that could deadlock it.
+- **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` → `todowrite`, `read_todos_tool_call` → `todoread`, `create_plan_tool_call` → `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 variants are soft-denied on the held Run with a populated typed error/`rejected`/`allowlisted:false` result (or `throw` when the CLI has no typed error shape) so the turn continues; unknown future request fields still fail the Run explicitly rather than receiving a guessed response that could deadlock it.
 - **Progress-only fragments can get one continuation** — if a real tool-enabled turn ends with a short progress fragment ("Checking the workspace", "Looking into it now") and no host tool call, the provider opens one follow-up Run with a synthetic user nudge so the model can call a listed tool or finish the answer. Complete answers that merely start with those verbs are not continued. Title/compaction turns (`allowTools=false`) never continue. If the continuation fails, the original `turn_ended` is still reported as a successful stop.
 - **Tool availability is per OpenCode agent** — Cursor can request native capabilities such as Task even when a child or restricted OpenCode agent did not advertise the corresponding host tool. The provider prompts Cursor with the exact current catalog and checks every decoded host-tool exec request against it. An unavailable request is answered on Cursor's correlated typed result channel and is never emitted as OpenCode's `invalid` tool.
 - **Host web tools use collision-safe aliases** — Cursor sees `custom_websearch` / `custom_webfetch`, and the held Run maps each alias back to an executable OpenCode tool with its schema, permission check, and correlated result intact. The plugin registers its search fallback directly as `custom_websearch`, avoiding OpenCode's reserved `websearch` id filter for third-party providers and taking precedence over MCP search providers such as Brave without host environment configuration. Exact host `webfetch` is translated the same way. Cursor's UI-bound native web interactions stay disabled because their approval replies cannot carry OpenCode tool results.

package/dist/language-model.d.ts

@@ -19,6 +19,10 @@ export declare function resolveRetryPolicy(options: CursorRetryOptions | undefin
 export declare function connectFrameError(payload: string): CursorProviderError;
 /** Restore the last real catalog solely for lifecycle turns such as compaction. */
 export declare function restoreTurnToolCatalog(sessionKey: string, tools: OpencodeToolDef[]): void;
+/** Record the authoritative host todo list for an OpenCode session. */
+export declare function rememberMirroredTodos(sessionKey: string | undefined, todos: ReadonlyArray<Record<string, unknown>>): void;
+/** Copy of the last known host todo list for an OpenCode session, if any. */
+export declare function snapshotMirroredTodosBySession(sessionKey: string | undefined): Array<Record<string, unknown>> | undefined;
 type V3Part = LanguageModelV3StreamPart;
 export declare function createCursorLanguageModel(modelId: string, providerId: string, options: CreateCursorOptions): LanguageModelV3;
 export declare function pumpWithRecovery(input: {

package/dist/language-model.js

@@ -11,7 +11,7 @@ import { buildGitDiffExecMessages } from "./protocol/git-diff.js";
 import { cursorExecVariantByRequestField, describeCursorExecVariant } from "./protocol/exec-variants.js";
 import { appendWorkspaceRootGrounding } from "./protocol/workspace-grounding.js";
 import { progressOnlyContinuationPrompt, shouldContinueProgressOnlyTurn, } from "./protocol/progress-continuation.js";
-import { advertisedToolNamesFromDescriptors, extractExecDisplayCallId, extractProtobufSubmessage, listProtobufFieldNumbers, parseDisplayToolCall, resolveBridgedOpenCodeToolCall, } from "./protocol/tool-call-bridge.js";
+import { advertisedToolNamesFromDescriptors, extractExecDisplayCallId, extractProtobufSubmessage, listProtobufFieldNumbers, parseDisplayToolCall, resolveBridgedOpenCodeToolCall, snapshotMirroredTodos, snapshotMirroredTodosFromReadOutput, } from "./protocol/tool-call-bridge.js";
 import { handleKvServerMessage } from "./protocol/kv.js";
 import { buildAskQuestionInteractionReply, buildAsyncAskQuestionCompletion, buildCreatePlanInteractionReply, buildSwitchModeInteractionReply, handleInteractionQuery, } from "./protocol/interactions.js";
 import { ASK_QUESTION_RESULT_FIELD, askQuestionResultFromToolOutput, askQuestionToolInput, } from "./protocol/ask-question.js";
@@ -326,6 +326,43 @@ function snapshotToolCatalog(sessionKey) {
         return [];
     return structuredClone(toolCatalogBySession.get(sessionKey) ?? []);
 }
+// Last known full host todo list per OpenCode session. Run-local
+// `session.mirroredTodos` dies with the Run (turn_ended closes the session),
+// but merges in later turns still need a base — same shape of problem as the
+// tool catalog above, same solution. In-memory only: never enters the prompt,
+// RequestContext, or persisted restart state, so the cache prefix is untouched.
+// Refreshed on every todo write/read we observe; replaced wholesale, never
+// merged, so it tracks host truth instead of accumulating guesses.
+const mirroredTodosBySession = new Map();
+/** Record the authoritative host todo list for an OpenCode session. */
+export function rememberMirroredTodos(sessionKey, todos) {
+    if (!sessionKey)
+        return;
+    mirroredTodosBySession.delete(sessionKey);
+    mirroredTodosBySession.set(sessionKey, todos.map((t) => ({ ...t })));
+    while (mirroredTodosBySession.size > MAX_TURN_STATE_SESSIONS) {
+        const oldest = mirroredTodosBySession.keys().next().value;
+        if (!oldest)
+            break;
+        mirroredTodosBySession.delete(oldest);
+    }
+}
+/** Copy of the last known host todo list for an OpenCode session, if any. */
+export function snapshotMirroredTodosBySession(sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    const todos = mirroredTodosBySession.get(sessionKey);
+    return todos ? todos.map((t) => ({ ...t })) : undefined;
+}
+/**
+ * Store a bridged/observed full todo snapshot on both the live Run session
+ * (for merges later this turn) and the per-OpenCode-session copy (for merges
+ * in later turns and across checkpoint resumes).
+ */
+function storeMirroredTodos(session, todos) {
+    session.mirroredTodos = todos.map((t) => ({ ...t }));
+    rememberMirroredTodos(session.openCodeSessionId, session.mirroredTodos);
+}
 function rememberPostCompactionRebase(sessionKey) {
     postCompactionRebaseBySession.delete(sessionKey);
     postCompactionRebaseBySession.add(sessionKey);
@@ -573,6 +610,8 @@ export async function pumpWithRecovery(input) {
             if (recovery.kind === "resume") {
                 session.usageEstimate = { ...pumpedSession.usageEstimate };
                 session.editToolCalls = new Map(pumpedSession.editToolCalls);
+                // mirroredTodos rides along via rememberMirroredTodos (per-OpenCode-
+                // session, seeded in startSession) — no handoff needed here.
             }
             input.onSession?.(session);
         }
@@ -977,6 +1016,10 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         pending: new Map(),
         displayToolCalls: new Map(),
         editToolCalls: new Map(),
+        // Seed from the per-OpenCode-session copy: merges in this turn (and after
+        // checkpoint resumes/rebases, which rebuild the session here) expand
+        // against the last observed host list, not an empty one.
+        mirroredTodos: snapshotMirroredTodosBySession(lifecycle ? undefined : sessionKey),
         nextBridgedExecId: 900_000,
         blobs: new Map(),
         toolDescriptors,
@@ -1362,6 +1405,16 @@ export function deliverContinuationResults(session, trailingToolResults) {
                 continue;
             return undefined;
         }
+        // A host `todoread` result is the authoritative list. Refresh the mirrored
+        // snapshot (direct reads and bridged native reads alike) so later merges
+        // apply onto host truth, not a stale write.
+        if (pending.toolName === "todoread" && r.error === undefined) {
+            const snapshot = snapshotMirroredTodosFromReadOutput(r.output);
+            if (snapshot !== undefined) {
+                storeMirroredTodos(session, snapshot);
+                trace(`continuation: mirrored todoread snapshot items=${snapshot.length}`);
+            }
+        }
         session.usageEstimate.inputTokens += estimateTokens(r.output.length);
         if (pending.bridged) {
             trace(`continuation: completed bridged result execId=${r.execId} toolName=${pending.toolName ?? r.toolName} outLen=${r.output.length}`);
@@ -2113,7 +2166,7 @@ export async function pump(session, controller, ids, abortSignal) {
                         trace(`display tool_call_completed: SKIPPED (allowTools=false) callId=${callId}`);
                     }
                     else {
-                        const display = parseDisplayToolCall(callId, toolCall);
+                        const display = parseDisplayToolCall(callId, toolCall, session.mirroredTodos);
                         const advertised = advertisedToolNamesFromDescriptors(session.toolDescriptors);
                         const bridged = display
                             ? resolveBridgedOpenCodeToolCall(display, advertised)
@@ -2134,6 +2187,13 @@ export async function pump(session, controller, ids, abortSignal) {
                                 `advertised=[${advertised.join(",")}]`);
                         }
                         else {
+                            // Snapshot only Cursor todo writes (not create_plan's synthetic
+                            // "plan" prepend) so later merge patches apply onto a real list.
+                            if (bridged.toolName === "todowrite" && bridged.variant === "update_todos_tool_call") {
+                                const snapshot = snapshotMirroredTodos(bridged.args.todos);
+                                if (snapshot !== undefined)
+                                    storeMirroredTodos(session, snapshot);
+                            }
                             const execId = session.nextBridgedExecId++;
                             sessionManager.registerPending(execId, session, "bridged", bridged.toolName, true);
                             const toolCallId = `cursor_${session.sessionId}_${execId}`;
@@ -2396,6 +2456,16 @@ export async function pump(session, controller, ids, abortSignal) {
                         }
                         // Keep the stream open; the result arrives on the next doStream call.
                         sessionManager.registerPending(parsed.id, session, parsed.resultField, parsed.toolName, false, parsed.resultMetadata);
+                        // A direct host `todowrite` is a replace-all snapshot: it is the new
+                        // truth for later Cursor merge patches, which otherwise apply onto a
+                        // stale (or empty) mirrored list.
+                        if (parsed.toolName === "todowrite") {
+                            const snapshot = snapshotMirroredTodos(parsed.args.todos);
+                            if (snapshot !== undefined) {
+                                storeMirroredTodos(session, snapshot);
+                                trace(`exec: mirrored todowrite snapshot items=${snapshot.length}`);
+                            }
+                        }
                         // tc.input is already a JSON string (LanguageModelV3ToolCall.input).
                         trace(`exec: EMITTED tool-call toolCallId=${tc.toolCallId} toolName=${tc.toolName} inputLen=${tc.input.length}`);
                         emittedHostTools++;
@@ -2781,12 +2851,18 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
     if (names.has("plan_enter")) {
         instructions.push("- To enter plan mode, call the OpenCode `plan_enter` tool. Cursor-native SwitchMode requests for plan/spec are also accepted and answered through it.");
     }
-    else if (names.has("todowrite")) {
-        instructions.push("- For planning task lists, call the OpenCode `todowrite` tool and/or write the plan as normal markdown.");
-    }
     if (names.has("plan_exit")) {
         instructions.push("- To leave plan mode, call the OpenCode `plan_exit` tool. Cursor-native SwitchMode for any non-plan target (agent, build, chat, debug, edit, background, multitask, triage, project, …) is also accepted and answered through it; the provider then injects the Cursor CLI-shaped mode reminder for that target.");
     }
+    // Prefer host todos whenever advertised. Keep guidance terse — spelling out
+    // Cursor TodoWrite vs TodoRead / MCP alias collisions teaches the model to
+    // inventory catalogs instead of just calling the host tools.
+    if (names.has("todowrite") || names.has("todoread")) {
+        const write = names.has("todowrite") ? "`todowrite`" : undefined;
+        const read = names.has("todoread") ? "`todoread`" : undefined;
+        const tools = write && read ? `${write} / ${read}` : (write ?? read);
+        instructions.push(`- For task-list create/update/complete/cancel${read ? "/read" : ""}, call OpenCode ${tools}; do not use Cursor TodoWrite, and do not narrate Cursor-vs-OpenCode todo-tool differences.`);
+    }
     if (names.has(CUSTOM_WEBSEARCH_TOOL)) {
         instructions.push(`- For web searches, call \`${CUSTOM_WEBSEARCH_TOOL}\`; do not use Cursor's native WebSearch interaction.`);
     }
@@ -2828,8 +2904,8 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
         `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.`,
         subagents.executor
-            ? "Call only tools in that exact list for ordinary host execution. Cursor-native Task/subagent requests are permitted because a compatible host executor is listed. Bridged Cursor interactions named below (AskQuestion, SwitchMode, CreatePlan, …) are not OpenCode/MCP catalog tools — raise them normally and do not narrate that they are missing."
-            : "Call only tools in that exact list for ordinary host execution. Bridged Cursor interactions named below (AskQuestion, SwitchMode, CreatePlan, …) are not OpenCode/MCP catalog tools — raise them normally and do not narrate that they are missing. Other unlisted Cursor-native tools are not bridged; complete the work with the listed tools or explain the limitation without claiming a missing MCP tool.",
+            ? "Call only tools in that exact OpenCode list for ordinary host execution. Cursor-native Task/subagent requests are permitted because a compatible host executor is listed. Bridged Cursor interactions named below (AskQuestion, SwitchMode, CreatePlan, …) are not OpenCode/MCP catalog tools — raise them normally and do not narrate that they are missing."
+            : "Call only tools in that exact OpenCode list for ordinary host execution. Bridged Cursor interactions named below (AskQuestion, SwitchMode, CreatePlan, …) are not OpenCode/MCP catalog tools — raise them normally and do not narrate that they are missing. Other unlisted Cursor-native tools are not bridged; complete the work with the listed tools or explain the limitation without claiming a missing MCP tool.",
         ...(instructions.length > 0
             ? ["Use these OpenCode tools instead of equivalent Cursor-native UI interactions:"]
             : []),

package/dist/pricing-data.d.ts

@@ -125,6 +125,11 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 3.5;
         readonly cache_read: 0.075;
     };
+    readonly "gemini-3.8-flash": {
+        readonly input: 0.75;
+        readonly output: 3.5;
+        readonly cache_read: 0.075;
+    };
     readonly "glm-5.2": {
         readonly input: 1.4;
         readonly output: 4.4;
@@ -185,6 +190,12 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 1.2;
         readonly cache_read: 0.02;
         readonly cache_write: 0.25;
+        readonly context_over_200k: {
+            readonly input: 0.4;
+            readonly output: 1.2;
+            readonly cache_read: 0.04;
+            readonly cache_write: 0.5;
+        };
     };
     readonly "gpt-5.6-sol": {
         readonly input: 4;
@@ -203,6 +214,12 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 12;
         readonly cache_read: 0.2;
         readonly cache_write: 2.5;
+        readonly context_over_200k: {
+            readonly input: 4;
+            readonly output: 12;
+            readonly cache_read: 0.4;
+            readonly cache_write: 5;
+        };
     };
     readonly "grok-4.5": {
         readonly input: 2;
@@ -234,6 +251,11 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 15;
         readonly cache_read: 0.3;
     };
+    readonly "muse-spark-1.3": {
+        readonly input: 1.25;
+        readonly output: 4.25;
+        readonly cache_read: 0.15;
+    };
 };
 export declare const CURSOR_MODEL_CONTEXTS: {
     readonly "claude-fable-5": {
@@ -310,6 +332,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
         readonly maxContext: 200000;
         readonly maxContextForMaxMode: 1000000;
     };
+    readonly "gemini-3.8-flash": {
+        readonly maxContext: 200000;
+        readonly maxContextForMaxMode: 1000000;
+    };
     readonly "glm-5.2": {
         readonly maxContext: 200000;
     };
@@ -341,6 +367,7 @@ export declare const CURSOR_MODEL_CONTEXTS: {
     };
     readonly "gpt-5.6-luna": {
         readonly maxContext: 272000;
+        readonly maxContextForMaxMode: 1000000;
     };
     readonly "gpt-5.6-sol": {
         readonly maxContext: 272000;
@@ -348,6 +375,7 @@ export declare const CURSOR_MODEL_CONTEXTS: {
     };
     readonly "gpt-5.6-terra": {
         readonly maxContext: 272000;
+        readonly maxContextForMaxMode: 1000000;
     };
     readonly "grok-4.5": {
         readonly maxContext: 256000;
@@ -362,6 +390,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
         readonly maxContext: 200000;
         readonly maxContextForMaxMode: 1000000;
     };
+    readonly "muse-spark-1.3": {
+        readonly maxContext: 300000;
+        readonly maxContextForMaxMode: 1000000;
+    };
 };
 export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "claude-fable-5": {
@@ -421,6 +453,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "gemini-3.7-flash": {
         readonly supportsImages: true;
     };
+    readonly "gemini-3.8-flash": {
+        readonly supportsImages: true;
+    };
     readonly "glm-5.2": {
         readonly supportsImages: false;
     };
@@ -469,4 +504,7 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "kimi-k3": {
         readonly supportsImages: true;
     };
+    readonly "muse-spark-1.3": {
+        readonly supportsImages: true;
+    };
 };

package/dist/pricing-data.js

@@ -125,6 +125,11 @@ export const CURSOR_MODEL_COSTS = {
         "output": 3.5,
         "cache_read": 0.075
     },
+    "gemini-3.8-flash": {
+        "input": 0.75,
+        "output": 3.5,
+        "cache_read": 0.075
+    },
     "glm-5.2": {
         "input": 1.4,
         "output": 4.4,
@@ -184,7 +189,13 @@ export const CURSOR_MODEL_COSTS = {
         "input": 0.2,
         "output": 1.2,
         "cache_read": 0.02,
-        "cache_write": 0.25
+        "cache_write": 0.25,
+        "context_over_200k": {
+            "input": 0.4,
+            "output": 1.2,
+            "cache_read": 0.04,
+            "cache_write": 0.5
+        }
     },
     "gpt-5.6-sol": {
         "input": 4,
@@ -202,7 +213,13 @@ export const CURSOR_MODEL_COSTS = {
         "input": 2,
         "output": 12,
         "cache_read": 0.2,
-        "cache_write": 2.5
+        "cache_write": 2.5,
+        "context_over_200k": {
+            "input": 4,
+            "output": 12,
+            "cache_read": 0.4,
+            "cache_write": 5
+        }
     },
     "grok-4.5": {
         "input": 2,
@@ -233,6 +250,11 @@ export const CURSOR_MODEL_COSTS = {
         "input": 3,
         "output": 15,
         "cache_read": 0.3
+    },
+    "muse-spark-1.3": {
+        "input": 1.25,
+        "output": 4.25,
+        "cache_read": 0.15
     }
 };
 export const CURSOR_MODEL_CONTEXTS = {
@@ -310,6 +332,10 @@ export const CURSOR_MODEL_CONTEXTS = {
         "maxContext": 200000,
         "maxContextForMaxMode": 1000000
     },
+    "gemini-3.8-flash": {
+        "maxContext": 200000,
+        "maxContextForMaxMode": 1000000
+    },
     "glm-5.2": {
         "maxContext": 200000
     },
@@ -340,14 +366,16 @@ export const CURSOR_MODEL_CONTEXTS = {
         "maxContextForMaxMode": 1000000
     },
     "gpt-5.6-luna": {
-        "maxContext": 272000
+        "maxContext": 272000,
+        "maxContextForMaxMode": 1000000
     },
     "gpt-5.6-sol": {
         "maxContext": 272000,
         "maxContextForMaxMode": 1000000
     },
     "gpt-5.6-terra": {
-        "maxContext": 272000
+        "maxContext": 272000,
+        "maxContextForMaxMode": 1000000
     },
     "grok-4.5": {
         "maxContext": 256000
@@ -361,6 +389,10 @@ export const CURSOR_MODEL_CONTEXTS = {
     "kimi-k3": {
         "maxContext": 200000,
         "maxContextForMaxMode": 1000000
+    },
+    "muse-spark-1.3": {
+        "maxContext": 300000,
+        "maxContextForMaxMode": 1000000
     }
 };
 export const CURSOR_MODEL_CAPABILITIES = {
@@ -421,6 +453,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "gemini-3.7-flash": {
         "supportsImages": true
     },
+    "gemini-3.8-flash": {
+        "supportsImages": true
+    },
     "glm-5.2": {
         "supportsImages": false
     },
@@ -468,5 +503,8 @@ export const CURSOR_MODEL_CAPABILITIES = {
     },
     "kimi-k3": {
         "supportsImages": true
+    },
+    "muse-spark-1.3": {
+        "supportsImages": true
     }
 };

package/dist/protocol/messages.js

@@ -257,11 +257,24 @@ export function createMessageTypes() {
     addType(root, "PiFindToolCall", [{ id: 1, name: "args", type: "PiFindToolArgs" }]);
     addType(root, "PiLsToolCall", [{ id: 1, name: "args", type: "PiLsToolArgs" }]);
     // Display-only native tools Cursor may complete without an ExecServerMessage.
+    // ReadTodos mirrors UpdateTodos: args + result (see agent.v1 ReadTodosToolCall).
     addType(root, "ReadTodosArgs", [
         { id: 1, name: "status_filter", type: "TodoStatus", repeated: true },
         { id: 2, name: "id_filter", type: "string", repeated: true },
     ]);
-    addType(root, "ReadTodosToolCall", [{ id: 1, name: "args", type: "ReadTodosArgs" }]);
+    addType(root, "ReadTodosSuccess", [
+        { id: 1, name: "todos", type: "TodoItem", repeated: true },
+        { id: 2, name: "total_count", type: "int32" },
+    ]);
+    addType(root, "ReadTodosError", [{ id: 1, name: "error", type: "string" }]);
+    addType(root, "ReadTodosResult", [
+        { id: 1, name: "success", type: "ReadTodosSuccess" },
+        { id: 2, name: "error", type: "ReadTodosError" },
+    ], [{ name: "result", fields: ["success", "error"] }]);
+    addType(root, "ReadTodosToolCall", [
+        { id: 1, name: "args", type: "ReadTodosArgs" },
+        { id: 2, name: "result", type: "ReadTodosResult" },
+    ]);
     addType(root, "AwaitArgs", [
         { id: 1, name: "task_id", type: "string" },
         { id: 2, name: "block_until_ms", type: "uint32" },

package/dist/protocol/tool-call-bridge.d.ts

@@ -19,10 +19,38 @@ export type BridgedOpenCodeToolCall = {
     callId: string;
     variant: string;
 };
+/**
+ * Normalize a full todo snapshot for `mirroredTodos` storage. Returns
+ * undefined when the input is not a todo array (nothing to learn). Drops the
+ * synthetic "plan" id minted for create_plan mirrors so later merges never
+ * resurrect it.
+ */
+export declare function snapshotMirroredTodos(todos: unknown): Array<Record<string, unknown>> | undefined;
+/**
+ * Refresh the mirrored snapshot from a host `todoread` tool result. The host
+ * list is authoritative; returns undefined when the output is not recognizable
+ * todo JSON (prose, caps, errors) so a stale-but-useful snapshot survives.
+ */
+export declare function snapshotMirroredTodosFromReadOutput(output: string): Array<Record<string, unknown>> | undefined;
+/**
+ * Overlay Cursor merge patches onto a previously mirrored full todo list.
+ * Preserves prior order; appends newly introduced ids in patch order.
+ *
+ * Matching is by id first, then by exact (trimmed) content. The content
+ * fallback covers mixed flows where the prior snapshot came from a direct
+ * host `todowrite` (positional ids) while the patch references Cursor-side
+ * ids for the same tasks. Patch items with neither an id/content match nor
+ * their own content are skipped — a status-only update for an unknown item
+ * cannot be mapped onto the host list.
+ */
+export declare function applyTodoMerge(prior: ReadonlyArray<Record<string, unknown>>, patch: unknown): Array<Record<string, unknown>>;
 /**
  * Decode a Cursor ToolCall oneof into a display tool call we can bridge.
+ *
+ * @param priorMirroredTodos Last full todo snapshot mirrored this Run; used to
+ *   expand Cursor `merge: true` updates that omit ToolCallCompleted.success.todos.
  */
-export declare function parseDisplayToolCall(callId: string, toolCall: Record<string, unknown> | undefined): DisplayToolCall | undefined;
+export declare function parseDisplayToolCall(callId: string, toolCall: Record<string, unknown> | undefined, priorMirroredTodos?: ReadonlyArray<Record<string, unknown>>): DisplayToolCall | undefined;
 /**
  * Pick an advertised OpenCode tool for a display call, remapping args as needed.
  * Returns undefined when nothing compatible is advertised this turn.

package/dist/protocol/tool-call-bridge.js

@@ -46,11 +46,13 @@ const VARIANT_TO_OPENCODE = {
 const TOOL_CALL_VARIANTS = Object.keys(VARIANT_TO_OPENCODE);
 // ToolCallCompleted is a notification, not an execution request. Only mirror
 // client-visible state whose authoritative final value is already present in
-// the completed payload. Data-returning, interactive, and side-effecting calls
+// the completed payload (or reconstructable from a prior mirrored snapshot for
+// Cursor todo merges). Data-returning, interactive, and side-effecting calls
 // must use an exec/interaction request channel where Cursor can receive their
 // actual result.
 const DISPLAY_STATE_MIRROR_VARIANTS = new Set([
     "update_todos_tool_call",
+    "read_todos_tool_call",
     "create_plan_tool_call",
 ]);
 function asRecord(v) {
@@ -97,14 +99,169 @@ function mapTodos(raw) {
         };
     });
 }
+/**
+ * Normalize a full todo snapshot for `mirroredTodos` storage. Returns
+ * undefined when the input is not a todo array (nothing to learn). Drops the
+ * synthetic "plan" id minted for create_plan mirrors so later merges never
+ * resurrect it.
+ */
+export function snapshotMirroredTodos(todos) {
+    if (!Array.isArray(todos))
+        return undefined;
+    return mapTodos(todos).filter((t) => {
+        const id = typeof t.id === "string" ? t.id : "";
+        return id.length > 0 && id !== "plan";
+    });
+}
+/**
+ * Refresh the mirrored snapshot from a host `todoread` tool result. The host
+ * list is authoritative; returns undefined when the output is not recognizable
+ * todo JSON (prose, caps, errors) so a stale-but-useful snapshot survives.
+ */
+export function snapshotMirroredTodosFromReadOutput(output) {
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch {
+        return undefined;
+    }
+    const list = Array.isArray(parsed) ? parsed : (asRecord(parsed)?.todos ?? undefined);
+    if (!Array.isArray(list))
+        return undefined;
+    return snapshotMirroredTodos(list);
+}
+/**
+ * Overlay Cursor merge patches onto a previously mirrored full todo list.
+ * Preserves prior order; appends newly introduced ids in patch order.
+ *
+ * Matching is by id first, then by exact (trimmed) content. The content
+ * fallback covers mixed flows where the prior snapshot came from a direct
+ * host `todowrite` (positional ids) while the patch references Cursor-side
+ * ids for the same tasks. Patch items with neither an id/content match nor
+ * their own content are skipped — a status-only update for an unknown item
+ * cannot be mapped onto the host list.
+ */
+export function applyTodoMerge(prior, patch) {
+    const rawPatch = Array.isArray(patch) ? patch : [];
+    const mappedPatch = mapTodos(patch);
+    const byId = new Map();
+    const byContent = new Map();
+    // Patch ids already folded into a prior record via content match: never
+    // re-emit them as new items in the output phase.
+    const consumedPatchIds = new Set();
+    // Patch ids accepted as genuinely new content: the only patch ids the
+    // output phase may append. Orphans skipped above (unknown id, no content)
+    // must not leak back in here.
+    const appendedPatchIds = new Set();
+    for (const item of prior) {
+        const id = typeof item.id === "string" && item.id.length > 0 ? item.id : "";
+        if (!id)
+            continue;
+        const normalized = {
+            id,
+            content: typeof item.content === "string" ? item.content : "",
+            status: typeof item.status === "string" ? item.status : mapTodoStatus(item.status),
+            priority: typeof item.priority === "string" && item.priority ? item.priority : "medium",
+        };
+        byId.set(id, normalized);
+        const key = normalized.content.trim();
+        if (key && !byContent.has(key))
+            byContent.set(key, normalized);
+    }
+    const overlay = (target, item, raw) => {
+        // Only overwrite fields the patch actually carries. mapTodos fills
+        // defaults ("" content, "pending" status, "medium" priority) that must not
+        // clobber a prior item when Cursor sends an id+status-only patch.
+        const next = { ...target, id: target.id };
+        if (typeof raw.content === "string" && raw.content.length > 0) {
+            next.content = raw.content;
+        }
+        if (raw.status !== undefined && raw.status !== null) {
+            next.status = String(item.status);
+        }
+        if (typeof raw.priority === "string" && raw.priority) {
+            next.priority = raw.priority;
+        }
+        return next;
+    };
+    for (let index = 0; index < mappedPatch.length; index++) {
+        const item = mappedPatch[index];
+        const raw = asRecord(rawPatch[index]) ?? {};
+        const id = String(item.id);
+        const byIdMatch = byId.get(id);
+        if (byIdMatch) {
+            const merged = overlay(byIdMatch, item, raw);
+            byId.set(id, merged);
+            // Keep the content index pointing at the fresh record so later
+            // content-fallback matches never merge onto a stale copy.
+            const oldKey = typeof byIdMatch.content === "string" ? byIdMatch.content.trim() : "";
+            const newKey = typeof merged.content === "string" ? merged.content.trim() : "";
+            if (oldKey && byContent.get(oldKey) === byIdMatch)
+                byContent.delete(oldKey);
+            if (newKey && !byContent.has(newKey))
+                byContent.set(newKey, merged);
+            continue;
+        }
+        const contentKey = typeof raw.content === "string" && raw.content.trim().length > 0
+            ? raw.content.trim()
+            : "";
+        const byContentMatch = contentKey ? byContent.get(contentKey) : undefined;
+        if (byContentMatch) {
+            // Same task, different id space (host positional ids vs Cursor ids).
+            // Keep the prior id so snapshot identity stays stable and order is
+            // preserved; adopt the patch's status/priority/content.
+            const merged = overlay(byContentMatch, item, raw);
+            byId.set(String(byContentMatch.id), merged);
+            if (contentKey)
+                byContent.set(contentKey, merged);
+            consumedPatchIds.add(id);
+            continue;
+        }
+        if (!contentKey)
+            continue;
+        byId.set(id, item);
+        byContent.set(contentKey, item);
+        appendedPatchIds.add(id);
+    }
+    const out = [];
+    const seen = new Set();
+    for (const item of prior) {
+        const id = typeof item.id === "string" ? item.id : "";
+        if (!id || seen.has(id))
+            continue;
+        const next = byId.get(id);
+        if (next) {
+            out.push(next);
+            seen.add(id);
+        }
+    }
+    for (const item of mappedPatch) {
+        const id = String(item.id);
+        // Id-matched items are already emitted under the prior id; content-matched
+        // items were folded into the prior record (not appended under the foreign
+        // patch id); orphans were skipped outright. Only genuinely new content
+        // reaches the host list.
+        if (seen.has(id) || consumedPatchIds.has(id))
+            continue;
+        if (!appendedPatchIds.has(id))
+            continue;
+        out.push(item);
+        seen.add(id);
+    }
+    return out;
+}
 function unwrapArgs(variantPayload) {
     const nested = asRecord(variantPayload.args);
     return nested ?? variantPayload;
 }
 /**
  * Decode a Cursor ToolCall oneof into a display tool call we can bridge.
+ *
+ * @param priorMirroredTodos Last full todo snapshot mirrored this Run; used to
+ *   expand Cursor `merge: true` updates that omit ToolCallCompleted.success.todos.
  */
-export function parseDisplayToolCall(callId, toolCall) {
+export function parseDisplayToolCall(callId, toolCall, priorMirroredTodos) {
     if (!toolCall || !callId)
         return undefined;
     const variant = findToolVariant(toolCall);
@@ -136,10 +293,16 @@ export function parseDisplayToolCall(callId, toolCall) {
         const success = asRecord(result?.success);
         const completedTodos = Array.isArray(success?.todos) ? success.todos : undefined;
         const isMerge = variant === "update_todos_tool_call" && args.merge === true;
-        // OpenCode todowrite replaces the whole list. For Cursor merge updates,
-        // only bridge when ToolCallCompleted includes the final merged list.
+        // OpenCode todowrite replaces the whole list. Prefer the completed payload;
+        // otherwise a non-merge args list; otherwise merge against the Run snapshot.
         const sourceTodos = completedTodos ?? (!isMerge ? args.todos : undefined);
-        const todos = mapTodos(sourceTodos);
+        const canMergeFromPrior = sourceTodos === undefined &&
+            isMerge &&
+            Array.isArray(priorMirroredTodos) &&
+            priorMirroredTodos.length > 0;
+        const todos = canMergeFromPrior
+            ? applyTodoMerge(priorMirroredTodos, args.todos)
+            : mapTodos(sourceTodos);
         if (variant === "create_plan_tool_call") {
             const overview = typeof args.overview === "string" ? args.overview.trim() : "";
             const plan = typeof args.plan === "string" ? args.plan.trim() : "";
@@ -158,7 +321,21 @@ export function parseDisplayToolCall(callId, toolCall) {
             variant,
             preferredToolName: "todowrite",
             args: { todos },
-            bridgeable: variant === "create_plan_tool_call" ? todos.length > 0 : Array.isArray(sourceTodos),
+            bridgeable: variant === "create_plan_tool_call"
+                ? todos.length > 0
+                : Array.isArray(sourceTodos) || canMergeFromPrior,
+        };
+    }
+    // Cursor TodoRead is the same display-only channel as TodoWrite (agent.v1
+    // read_todos_tool_call). OpenCode todoread takes an empty body; host filters
+    // are not part of the canonical schema, so drop status_filter / id_filter.
+    if (variant === "read_todos_tool_call") {
+        return {
+            callId,
+            variant,
+            preferredToolName: "todoread",
+            args: {},
+            bridgeable: true,
         };
     }
     if (variant === "edit_tool_call") {
@@ -295,6 +472,9 @@ export function resolveBridgedOpenCodeToolCall(display, advertised) {
                 todos: mapTodos(display.args.todos ?? mapped.args.todos),
             };
         }
+        if (toolName === "todoread") {
+            mapped.args = {};
+        }
         return {
             toolName: mapped.toolName,
             args: mapped.args,

package/dist/session.d.ts

@@ -147,6 +147,12 @@ export type CursorSession = {
      * or when we bridge the completed display call into an OpenCode tool-call.
      */
     displayToolCalls: Map<string, Record<string, unknown>>;
+    /**
+     * Last full todo snapshot successfully mirrored into OpenCode `todowrite`.
+     * Used to apply Cursor `merge: true` display updates that omit the final
+     * completed list so host todos still receive a replace-all snapshot.
+     */
+    mirroredTodos?: Array<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

package/dist/session.js

@@ -387,6 +387,7 @@ export class SessionManager {
         session.pumpOwner = null;
         session.pumpActive = false;
         session.displayToolCalls?.clear();
+        session.mirroredTodos = undefined;
         session.blobs?.clear();
         this.sessions.delete(session);
         if (session.openCodeSessionId &&

package/package.json

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