cursor-opencode-provider 0.2.4 → 0.2.6

package/dist/language-model.js

@@ -288,7 +288,7 @@ async function doStreamImpl(modelId, options, callOptions) {
             // Cursor can continue instead of deadlocking.
             const ids = trailingToolResults.map((r) => `${r.sessionId}:${r.execId}`).join(",");
             trace(`continuation: ${trailingToolResults.length} interrupted trailing tool result(s) [${ids}] — rebasing fresh Run`);
-            session = await openSession({ recovery: true });
+            session = await openSession({ recovery: { kind: "rebase" } });
         }
         else {
             // Fresh turn (prompt ends with user/assistant text). Historical tool
@@ -323,7 +323,7 @@ async function doStreamImpl(modelId, options, callOptions) {
                         abortSignal: callOptions.abortSignal,
                         promptTokens,
                         retryPolicy,
-                        recover: () => openSession({ recovery: true }),
+                        recover: (recovery) => openSession({ recovery }),
                         onSession: (next) => { activeSession = next; },
                     });
                     try {
@@ -361,6 +361,7 @@ export async function pumpWithRecovery(input) {
         maxAttempts: (input.maxRecoveries ?? 1) + 1,
     };
     const maxRecoveries = retryPolicy.maxAttempts - 1;
+    const requestUsage = { outputChars: 0 };
     input.onSession?.(session);
     for (let attempt = 0;; attempt++) {
         const pumpedSession = session;
@@ -371,6 +372,7 @@ export async function pumpWithRecovery(input) {
                 textId: crypto.randomUUID(),
                 reasoningId: crypto.randomUUID(),
                 promptTokens: input.promptTokens ?? 0,
+                requestUsage,
             }, input.abortSignal);
             return session;
         }
@@ -381,19 +383,26 @@ export async function pumpWithRecovery(input) {
             });
             if (!failure.transient)
                 throw failure;
-            if (!failure.replaySafe) {
+            const checkpoint = pumpedSession.resumeCheckpoint;
+            if (!failure.replaySafe && !checkpoint) {
                 throw retrySuppressedError(failure, "after visible output or stateful server activity", attempt + 1, maxRecoveries + 1);
             }
             if (attempt >= maxRecoveries) {
                 throw new CursorRetryExhaustedError(attempt + 1, failure);
             }
             trace(`Run interrupted: sessionId=${pumpedSession.sessionId} attempt=${attempt + 1}/${maxRecoveries} ` +
-                `err=${failure.message} — rebasing fresh Run`);
+                `err=${failure.message} — ${checkpoint ? `resuming ${checkpoint.length}B checkpoint` : "rebasing fresh Run"}`);
             sessionManager.close(pumpedSession, "remote-error", failure);
             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();
+            session = await input.recover(checkpoint
+                ? {
+                    kind: "resume",
+                    conversationId: pumpedSession.conversationId,
+                    checkpoint: Uint8Array.from(checkpoint),
+                }
+                : { kind: "rebase" });
             input.onSession?.(session);
         }
         finally {
@@ -419,18 +428,21 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     const tools = toolState.advertisedTools;
     const allowTools = toolState.allowTools;
     const resetState = resolveTurnConversationReset({ sessionKey, isCompaction });
-    const recovery = startOptions?.recovery === true;
+    const recovery = startOptions?.recovery;
+    const resuming = recovery?.kind === "resume";
     // Compaction must not reuse the prior conversation; its first normal turn
     // must also rebase so the summary-agent checkpoint cannot replace the normal
     // system prompt and OpenCode's newly compacted history.
-    const bound = bindConversationId(sessionKey, { reset: resetState.reset || recovery });
+    const bound = resuming
+        ? { conversationId: recovery.conversationId, reset: false, previousId: undefined }
+        : bindConversationId(sessionKey, { reset: resetState.reset || recovery?.kind === "rebase" });
     const conversationId = bound.conversationId;
     if (bound.reset) {
-        trace(`conversation reset: reason=${recovery ? "interrupted-run" : (resetState.reason ?? "unknown")} ` +
+        trace(`conversation reset: reason=${recovery?.kind === "rebase" ? "interrupted-run" : (resetState.reason ?? "unknown")} ` +
             `sessionKey=${sessionKey ?? "(none)"} ` +
             `previousId=${bound.previousId ?? "-"} → conversationId=${conversationId}`);
     }
-    const userText = recovery
+    const userText = recovery?.kind === "rebase"
         ? "Continue the interrupted turn from the conversation history above. Do not repeat completed work."
         : (extractUserText([...prompt].reverse().find((m) => m.role === "user")) || ".");
     const workspaceRoot = path.resolve(options.workspaceRoot || process.cwd());
@@ -439,7 +451,10 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     const systemPrompt = interactionGuidance
         ? [baseSystemPrompt, interactionGuidance].filter(Boolean).join("\n\n")
         : baseSystemPrompt;
-    const history = extractPromptHistory(prompt, { preserveTrailingUser: recovery });
+    const history = extractPromptHistory(prompt, {
+        preserveTrailingUser: recovery?.kind === "rebase",
+        toolResults: isCompaction ? "all" : (recovery?.kind === "rebase" ? "trailing" : "omit"),
+    });
     await loadAvailableModels();
     // Resolve the region-specific Run stream origin once per process (memoized
     // in agent-url.ts). Explicit agent host overrides skip GetServerConfig but
@@ -482,7 +497,9 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         : [];
     // CLI parity: echo the last conversation_checkpoint_update as conversation_state.
     // After compaction reset there is no checkpoint — seed from OpenCode history.
-    const conversationState = bound.reset ? undefined : getCheckpoint(conversationId);
+    const conversationState = resuming
+        ? recovery.checkpoint
+        : (bound.reset ? undefined : getCheckpoint(conversationId));
     const reqBytes = buildRunRequest({
         text: userText,
         modelId: cursorModelId,
@@ -495,6 +512,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         tools,
         toolDescriptors,
         requestContext,
+        action: resuming ? "resume" : "user",
     });
     // Content hashes — Cursor content-addresses large payloads; logging these lets
     // us match a server get_blob_args.blob_id to what it wants served.
@@ -520,6 +538,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         `availableModels=${_availableModels?.length ?? 0} userTextLen=${userText.length} ` +
         `historyMsgs=${history.length} historyChars=${historyChars} ` +
         `checkpointLen=${conversationState?.length ?? 0} reset=${bound.reset} ` +
+        `resume=${resuming} ` +
         `usageEstimateIn=${usageEstimate.inputTokens} runRequestBytes=${reqBytes.length}`);
     if (hooksCtx)
         trace(`outbound Run hooks_additional_context: ${hooksCtx}`);
@@ -538,6 +557,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     const session = {
         sessionId: crypto.randomUUID(),
         conversationId,
+        resumeCheckpoint: undefined,
         openCodeSessionId: sessionKey,
         stream,
         frames: stream.frames()[Symbol.asyncIterator](),
@@ -643,6 +663,7 @@ export function deliverContinuationResults(session, trailingToolResults) {
         if (!pending.bridged) {
             try {
                 const shellResult = pending.resultField === "shell_stream"
+                    || pending.resultField === "background_shell_spawn_result"
                     ? consumeCursorShellResult(r.toolCallId, r.output)
                     : undefined;
                 frames = buildExecClientMessages({
@@ -792,7 +813,7 @@ export async function pump(session, controller, ids, abortSignal) {
     const advertisedToolNameSet = new Set(advertisedToolNames);
     let textStarted = false;
     let reasoningStarted = false;
-    let emittedOutputChars = 0;
+    const requestUsage = ids.requestUsage ?? { outputChars: 0 };
     let replaySafe = true;
     // OpenCode cancels the ReadableStream between turns (see the cancel handler
     // in doStreamImpl). The frames iterator can still yield a final `done` after
@@ -847,6 +868,56 @@ export async function pump(session, controller, ids, abortSignal) {
             return false;
         }
     };
+    /**
+     * Cursor's streamed edit handshake reads the target before it sends the
+     * replacement through write_args. For a new file that read naturally fails,
+     * which makes the model abandon the edit and fall back to a shell heredoc.
+     * Treat only a missing target correlated to an edit_tool_call as an empty
+     * file, allowing Cursor to continue to the ordinary OpenCode write call.
+     */
+    const recoverMissingEditRead = (parsed, displayCallId) => {
+        if (!displayCallId ||
+            parsed.resultField !== "read_result" ||
+            parsed.toolName !== "read" ||
+            !advertisedToolNameSet.has("write"))
+            return false;
+        const stored = session.displayToolCalls.get(displayCallId);
+        const display = parseDisplayToolCall(displayCallId, stored);
+        if (display?.variant !== "edit_tool_call" || display.bridgeable === false)
+            return false;
+        const requestedPath = typeof parsed.args.filePath === "string" ? parsed.args.filePath : "";
+        const editPath = typeof display.args.path === "string" ? display.args.path : "";
+        if (!requestedPath || !editPath)
+            return false;
+        const workspaceRoot = typeof session.requestContext.workspace_project_dir === "string"
+            ? session.requestContext.workspace_project_dir
+            : process.cwd();
+        const resolvePath = (value) => path.resolve(workspaceRoot, value);
+        const absolutePath = resolvePath(requestedPath);
+        if (absolutePath !== resolvePath(editPath) || fs.existsSync(absolutePath))
+            return false;
+        try {
+            for (const frame of buildExecClientMessages({
+                execId: parsed.id,
+                resultField: parsed.resultField,
+                output: "",
+                toolName: parsed.toolName,
+                resultMetadata: { path: requestedPath },
+            })) {
+                session.stream.write(frame);
+            }
+            trace(`exec: missing edit target treated as empty file id=${parsed.id} ` +
+                `path=${JSON.stringify(requestedPath)}; awaiting write_args`);
+            return true;
+        }
+        catch (e) {
+            const error = new Error(`Failed to recover Cursor edit read for a new file: ${e.message}`);
+            trace(`exec: edit read recovery FAILED ${error.message}`);
+            safeError(error);
+            sessionManager.close(session);
+            return true;
+        }
+    };
     /** AI SDK V3 requires text-end / reasoning-end before finish or tool-call. */
     const closeOpenSpans = () => {
         for (const part of spanEndParts({ textStarted, reasoningStarted, textId, reasoningId })) {
@@ -870,7 +941,7 @@ export async function pump(session, controller, ids, abortSignal) {
         }
         session.usageEstimate.outputTokens += estimateTokens(text.length);
         if (safeEnqueue({ type: "text-delta", id: textId, delta: text })) {
-            emittedOutputChars += text.length;
+            requestUsage.outputChars += text.length;
         }
     };
     const emitReasoning = (text) => {
@@ -883,7 +954,7 @@ export async function pump(session, controller, ids, abortSignal) {
         }
         session.usageEstimate.outputTokens += estimateTokens(text.length);
         if (safeEnqueue({ type: "reasoning-delta", id: reasoningId, delta: text })) {
-            emittedOutputChars += text.length;
+            requestUsage.outputChars += text.length;
         }
     };
     const emitFinish = (te, reason) => {
@@ -906,7 +977,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 cacheWrite: 0,
             },
             outputTokens: {
-                total: estimateTokens(emittedOutputChars),
+                total: estimateTokens(requestUsage.outputChars),
                 text: undefined,
                 reasoning: undefined,
             },
@@ -1044,6 +1115,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 const bytes = normalizeCheckpointBytes(checkpointRaw);
                 if (bytes && bytes.length > 0) {
                     setCheckpoint(session.conversationId, bytes);
+                    session.resumeCheckpoint = Uint8Array.from(bytes);
                     trace(`checkpoint: stored ${bytes.length}B for conversationId=${session.conversationId}`);
                 }
             }
@@ -1153,7 +1225,11 @@ export async function pump(session, controller, ids, abortSignal) {
                         trace(`exec request_context: replied`);
                     }
                     catch (e) {
-                        trace(`exec request_context: write FAILED ${e.message}`);
+                        const error = new Error(`Failed to answer Cursor request_context probe: ${e.message}`);
+                        trace(`exec request_context: write FAILED ${error.message}`);
+                        safeError(error);
+                        sessionManager.close(session);
+                        return;
                     }
                 }
                 else if (esm.mcp_state_exec_args) {
@@ -1179,10 +1255,6 @@ export async function pump(session, controller, ids, abortSignal) {
                 else {
                     const parsed = parseExecServerMessage(esm);
                     const displayCallId = extractExecDisplayCallId(esm);
-                    if (displayCallId) {
-                        session.displayToolCalls.delete(displayCallId);
-                        trace(`exec: claimed display callId=${displayCallId}`);
-                    }
                     trace(`exec: id=${parsed?.id} variant=${parsed ? Object.keys(parsed).join(",") : "none"} toolName=${parsed?.toolName} resultField=${parsed?.resultField}`);
                     if (parsed) {
                         if (parsed.localError) {
@@ -1219,8 +1291,15 @@ export async function pump(session, controller, ids, abortSignal) {
                                 return;
                             continue;
                         }
+                        if (recoverMissingEditRead(parsed, displayCallId))
+                            continue;
+                        if (displayCallId) {
+                            session.displayToolCalls.delete(displayCallId);
+                            trace(`exec: claimed display callId=${displayCallId}`);
+                        }
                         const tc = buildToolCallPart(parsed, session.sessionId);
-                        if (parsed.resultField === "shell_stream") {
+                        if (parsed.resultField === "shell_stream"
+                            || parsed.resultField === "background_shell_spawn_result") {
                             registerCursorShellCall(tc.toolCallId, parsed.resultMetadata);
                         }
                         // Keep the stream open; the result arrives on the next doStream call.
@@ -1257,7 +1336,8 @@ export async function pump(session, controller, ids, abortSignal) {
             else if (interactionQuery) {
                 // InteractionQuery is a must-reply channel, just like exec and KV. AI
                 // SDK has no Cursor-specific UI callback, so answer immediately with the
-                // conservative headless policy from protocol/interactions.ts.
+                // conservative headless policy from protocol/interactions.ts (including
+                // F14 create_plan auto-ack / empty plan_uri for CLI headless parity).
                 try {
                     const handled = handleInteractionQuery(interactionQuery, payload);
                     session.stream.write(handled.reply);
@@ -1290,7 +1370,13 @@ export async function pump(session, controller, ids, abortSignal) {
                             `found=${handled.found} echoed=${!!handled.echoed} ` +
                             `sessionBlobs=${session.blobs.size} convBlobs=${conversationBlobCount(session.conversationId)}`);
                     }
-                    catch { /* stream closed; pump will surface end */ }
+                    catch (e) {
+                        const error = new Error(`Failed to answer Cursor KV blob request: ${e.message}`);
+                        trace(`kv: write FAILED ${error.message}`);
+                        safeError(error);
+                        sessionManager.close(session);
+                        return;
+                    }
                 }
             }
         }
@@ -1423,6 +1509,11 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
     if (names.has("webfetch")) {
         instructions.push("- To fetch a known URL, call the OpenCode `webfetch` tool; do not use Cursor's native WebFetch interaction.");
     }
+    if (names.has("write")) {
+        instructions.push(names.has("edit")
+            ? "- For file changes, use OpenCode `edit` for targeted changes to existing files and `write` to create files or intentionally replace complete contents; do not use shell, Python, or heredocs to change file content while these tools are available."
+            : "- Use OpenCode `write` for file-content changes; do not use shell, Python, or heredocs to change file content while it is available.");
+    }
     return [
         `OpenCode exposes exactly these executable tools for this turn: ${[...names].map((name) => `\`${name}\``).join(", ")}.`,
         `Workspace root: ${JSON.stringify(workspaceRoot)}. Resolve workspace paths against exactly this root; never invent an absolute prefix, and verify uncertain paths with an available tool before using them.`,
@@ -1469,13 +1560,24 @@ export function cursorTurnEndedProviderMetadata(te) {
     };
 }
 /**
- * Prior prompt turns for a seed ConversationStateStructure after compaction
- * reset. Drops the trailing user message (live action), but preserves tool
- * result payloads as labeled assistant observations for Cursor's text history.
+ * Prior prompt turns for a seed ConversationStateStructure. Tool results must
+ * never be replayed as assistant-authored prose: that teaches the model to
+ * counterfeit `Tool result (...)` text instead of emitting a real tool call.
+ * Normal rebases omit old results; compaction can retain all results and
+ * interrupted continuations retain only the trailing live result suffix as
+ * explicit OpenCode-host observations.
  */
 export function extractPromptHistory(prompt, options) {
     const out = [];
-    for (const m of prompt) {
+    const toolResults = options?.toolResults ?? "omit";
+    let trailingToolStart = prompt.length;
+    if (toolResults === "trailing") {
+        while (trailingToolStart > 0 && prompt[trailingToolStart - 1]?.role === "tool") {
+            trailingToolStart--;
+        }
+    }
+    for (let messageIndex = 0; messageIndex < prompt.length; messageIndex++) {
+        const m = prompt[messageIndex];
         if (m.role === "system") {
             if (typeof m.content === "string" && m.content.length > 0) {
                 out.push({ role: "system", content: m.content });
@@ -1495,18 +1597,26 @@ export function extractPromptHistory(prompt, options) {
             continue;
         }
         if (m.role === "tool" && Array.isArray(m.content)) {
+            if (toolResults === "omit" ||
+                (toolResults === "trailing" && messageIndex < trailingToolStart))
+                continue;
             const results = [];
             for (const part of m.content) {
                 const p = part;
                 if (p.type !== "tool-result")
                     continue;
                 const toolName = typeof p.toolName === "string" && p.toolName ? p.toolName : "tool";
+                const toolCallId = typeof p.toolCallId === "string" ? p.toolCallId : "";
                 const result = toolResultOutputToText(p.output);
-                const label = result.isError ? "Tool error" : "Tool result";
-                results.push(`${label} (${toolName}):\n${result.text}`);
+                results.push(formatSeedToolObservation({
+                    toolName,
+                    toolCallId,
+                    output: result.text,
+                    isError: result.isError,
+                }));
             }
             if (results.length > 0)
-                appendSeedHistory(out, "assistant", results.join("\n\n"));
+                appendSeedHistory(out, "user", results.join("\n\n"));
         }
     }
     // Live user message is the Run action, not seed history.
@@ -1515,6 +1625,15 @@ export function extractPromptHistory(prompt, options) {
     }
     return out;
 }
+function formatSeedToolObservation(input) {
+    const metadata = JSON.stringify({
+        source: "opencode-tool",
+        tool: input.toolName,
+        callId: input.toolCallId,
+        status: input.isError ? "error" : "completed",
+    });
+    return `OpenCode host observation ${metadata}:\n${input.output}`;
+}
 function extractAssistantHistoryText(msg) {
     const content = msg.content;
     if (typeof content === "string")

package/dist/plugin.js

@@ -1,10 +1,10 @@
 import { CURSOR_COMPACTION_OPTION, CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
-import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtPayload } from "./auth.js";
+import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtExpiryMs } from "./auth.js";
 import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, readCache, discoverModels, isCacheFresh, parseCursorContextLimit } from "./models.js";
 import { opencodeGlobalCacheDir } from "./context/paths.js";
 import { readStoredAuth } from "./context/auth-store.js";
 import { resolveAgentUrl } from "./agent-url.js";
-import { captureCursorShellResult, cursorShellOriginalCommand, prepareCursorShellArgs, } from "./shell-timeout.js";
+import { captureCursorShellResult, cursorShellEnvForCall, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, } from "./shell-timeout.js";
 import { sessionActivity } from "./activity.js";
 const MODULE_URL = new URL("./index.js", import.meta.url).href;
 /**
@@ -275,7 +275,7 @@ export async function CursorPlugin(input) {
                     type: "oauth",
                     access: newTokens.accessToken,
                     refresh: newTokens.refreshToken,
-                    expires: decodeExpFromJwt(newTokens.accessToken),
+                    expires: decodeJwtExpiryMs(newTokens.accessToken) ?? Date.now(),
                     ...(extras.accountId !== undefined ? { accountId: extras.accountId } : {}),
                     ...(extras.enterpriseUrl !== undefined ? { enterpriseUrl: extras.enterpriseUrl } : {}),
                 });
@@ -336,13 +336,35 @@ export async function CursorPlugin(input) {
         async "tool.execute.before"(hookInput, output) {
             if (hookInput.tool !== "bash")
                 return;
+            // Keep args.command as the original display/permission command. Wrapping
+            // happens via shell.env (BASH_ENV / ZDOTDIR) so OpenCode's bash UI never
+            // stores or renders the private wrapper script.
             prepareCursorShellArgs(hookInput.callID, output.args);
         },
+        async "shell.env"(hookInput, output) {
+            const env = cursorShellEnvForCall(hookInput.callID);
+            if (!env)
+                return;
+            Object.assign(output.env, env);
+        },
         async "tool.execute.after"(hookInput, output) {
             if (hookInput.tool !== "bash")
                 return;
-            output.title = cursorShellOriginalCommand(hookInput.callID) ?? output.title;
-            output.output = captureCursorShellResult(hookInput.callID, output.output, output.metadata);
+            try {
+                output.title = cursorShellOriginalCommand(hookInput.callID) ?? output.title;
+                output.output = captureCursorShellResult(hookInput.callID, output.output, output.metadata);
+                // OpenCode's bash GUI falls back to metadata.output when output is empty
+                // (`props.output || props.metadata.output`), so strip private markers there too.
+                if (output.metadata && typeof output.metadata === "object") {
+                    const metadata = output.metadata;
+                    if (typeof metadata.output === "string") {
+                        metadata.output = sanitizeRegisteredCursorShellOutput(hookInput.callID, metadata.output);
+                    }
+                }
+            }
+            finally {
+                releaseCursorShellEnv(hookInput.callID);
+            }
         },
         async "chat.params"(hookInput, output) {
             if (hookInput.model.providerID !== CURSOR_PROVIDER_ID)
@@ -397,7 +419,7 @@ export async function CursorPlugin(input) {
                                     provider: CURSOR_PROVIDER_ID,
                                     access: result.accessToken,
                                     refresh: result.refreshToken,
-                                    expires: decodeExpFromJwt(result.accessToken),
+                                    expires: decodeJwtExpiryMs(result.accessToken) ?? Date.now(),
                                 };
                             },
                         };
@@ -469,9 +491,3 @@ export async function CursorPlugin(input) {
         },
     };
 }
-function decodeExpFromJwt(jwt) {
-    const payload = decodeJwtPayload(jwt);
-    if (payload && typeof payload.exp === "number")
-        return payload.exp * 1000;
-    return Date.now() + 3600_000;
-}

package/dist/protocol/interactions.d.ts

@@ -19,5 +19,12 @@ export declare class UnsupportedInteractionQueryError extends Error {
  * instead of accidentally restoring the heartbeat-only deadlock.
  */
 export declare function inspectInteractionQueryWire(agentServerPayload: Uint8Array): InteractionQueryWireInfo;
-/** Build the immediate typed response required by Cursor's Run RPC. */
+/**
+ * Build the immediate typed response required by Cursor's Run RPC.
+ *
+ * OpenCode has no Cursor UI callbacks, so every InteractionQuery is answered
+ * here with a conservative headless policy (reject UI-bound prompts; ack a few
+ * no-UI cases). See case 7 / F14 for create_plan auto-ack parity with Cursor
+ * CLI headless mode.
+ */
 export declare function handleInteractionQuery(query: Record<string, unknown>, agentServerPayload: Uint8Array): HandledInteraction;

package/dist/protocol/interactions.js

@@ -51,7 +51,14 @@ export function inspectInteractionQueryWire(agentServerPayload) {
         variantName: variantField === undefined ? undefined : variantNames[variantField],
     };
 }
-/** Build the immediate typed response required by Cursor's Run RPC. */
+/**
+ * Build the immediate typed response required by Cursor's Run RPC.
+ *
+ * OpenCode has no Cursor UI callbacks, so every InteractionQuery is answered
+ * here with a conservative headless policy (reject UI-bound prompts; ack a few
+ * no-UI cases). See case 7 / F14 for create_plan auto-ack parity with Cursor
+ * CLI headless mode.
+ */
 export function handleInteractionQuery(query, agentServerPayload) {
     const info = inspectInteractionQueryWire(agentServerPayload);
     if (info.id === undefined || info.variantField === undefined || !info.variantName) {
@@ -80,8 +87,14 @@ export function handleInteractionQuery(query, agentServerPayload) {
             outcome = "rejected";
             break;
         case 7:
+            // F14: create_plan_request_query auto-ack (Cursor CLI headless parity).
             // Cursor CLI's headless fallback acknowledges plan creation without a
-            // client-side URI; the plan remains in conversation state/checkpoints.
+            // client-side URI (`success` + empty `plan_uri`); the plan remains in
+            // conversation state / checkpoints. This provider mirrors that reply so
+            // the Run RPC does not deadlock waiting for UI approval. Impact: Cursor
+            // may treat the plan as accepted without an OpenCode UI confirm; local
+            // tool execution is still gated by OpenCode permissions. Do not change
+            // this to reject/prompt without CLI parity evidence.
             response = { create_plan_request_response: { result: { success: {}, plan_uri: "" } } };
             outcome = "acknowledged";
             break;

package/dist/protocol/messages.js

@@ -357,8 +357,11 @@ export function createMessageTypes() {
         { id: 2, name: "content", type: "string" },
         { id: 3, name: "total_lines", type: "int32" },
         { id: 4, name: "file_size", type: "int64" },
+        { id: 5, name: "data", type: "bytes" },
         { id: 6, name: "truncated", type: "bool" },
-    ]);
+        { id: 7, name: "output_blob_id", type: "bytes" },
+        { id: 8, name: "range_applied", type: "bool" },
+    ], [{ name: "output", fields: ["content", "data"] }]);
     addType(root, "ReadError", [
         { id: 1, name: "path", type: "string" },
         { id: 2, name: "error", type: "string" },
@@ -900,7 +903,9 @@ export function createMessageTypes() {
         { id: 2, name: "request_context", type: "RequestContext" },
     ]);
     addType(root, "ResumeAction", [
-        { id: 1, name: "conversation_id", type: "string" },
+        // Cursor CLI sends an empty ResumeAction. Field #2 is available for a
+        // refreshed RequestContext; the conversation id belongs to AgentRunRequest.
+        { id: 2, name: "request_context", type: "RequestContext" },
     ]);
     addType(root, "CancelAction", [
         { id: 1, name: "conversation_id", type: "string" },

package/dist/protocol/request.d.ts

@@ -10,8 +10,8 @@ export type RunRequestInput = {
     systemPrompt?: string;
     /**
      * Prior chat turns for a seed ConversationStateStructure (no checkpoint).
-     * Used after compaction reset so Cursor sees OpenCode's compacted history
-     * instead of an empty conversation.
+     * Tool outputs, when required for compaction/recovery, are represented as
+     * user-role OpenCode host observations rather than assistant-authored prose.
      */
     history?: SeedHistoryMessage[];
     /**
@@ -32,6 +32,8 @@ export type RunRequestInput = {
     toolDescriptors?: Array<Record<string, unknown>>;
     /** Prebuilt RequestContext (OpenCode-sourced). */
     requestContext?: Record<string, unknown>;
+    /** Resume the supplied checkpoint instead of submitting another user turn. */
+    action?: "user" | "resume";
 };
 /**
  * Seed ConversationStateStructure for the first turn (no checkpoint yet).

package/dist/protocol/request.js

@@ -54,9 +54,11 @@ export function buildRunRequest(input) {
             message_id: msgId,
         },
     };
-    if (requestContext) {
+    if (requestContext)
         userMessageAction.request_context = requestContext;
-    }
+    const action = input.action === "resume"
+        ? { resume_action: {} }
+        : { user_message_action: userMessageAction };
     const conversationState = input.conversationState && input.conversationState.length > 0
         ? input.conversationState
         : buildSeedConversationState({
@@ -65,9 +67,7 @@ export function buildRunRequest(input) {
         });
     const runRequest = {
         conversation_id: input.conversationId,
-        action: {
-            user_message_action: userMessageAction,
-        },
+        action,
         requested_model: {
             // The provider always selects a concrete model. Cursor's "default"
             // pseudo-model (Auto) is never used here — we send the real id plus the

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

@@ -7,7 +7,12 @@ const TODO_STATUS = {
     3: "completed",
     4: "cancelled",
 };
-/** Cursor ToolCall oneof field → default OpenCode tool id. */
+/**
+ * Cursor ToolCall oneof field → default OpenCode tool id.
+ *
+ * F11: `delete_tool_call` has no OpenCode builtin; it remaps to bash (see the
+ * delete_tool_call branch below for `rm -f -- <path>`).
+ */
 const VARIANT_TO_OPENCODE = {
     shell_tool_call: "bash",
     delete_tool_call: "bash",
@@ -121,6 +126,10 @@ export function parseDisplayToolCall(callId, toolCall) {
             args: mcpArgs,
         };
     }
+    // create_plan_tool_call here is display-state mirroring into todowrite.
+    // Separately, InteractionQuery create_plan_request_query is auto-acked in
+    // protocol/interactions.ts (F14 / CLI headless parity) — that ack is not an
+    // execution of this display payload.
     if (variant === "update_todos_tool_call" || variant === "create_plan_tool_call") {
         const result = asRecord(payload.result);
         const success = asRecord(result?.success);
@@ -238,6 +247,7 @@ export function parseDisplayToolCall(callId, toolCall) {
             args: {},
         };
     }
+    // F11: display-path delete → bash `rm -f` (OpenCode has no delete tool).
     if (variant === "delete_tool_call") {
         const path = typeof args.path === "string" ? args.path : "";
         return {

package/dist/protocol/tools.d.ts

@@ -1,4 +1,4 @@
-import type { CursorShellOutcome } from "../shell-timeout.js";
+import { type CursorShellOutcome } from "../shell-timeout.js";
 export declare const REQUEST_CONTEXT_RESULT_FIELD = 10;
 export type OpencodeToolDef = {
     name: string;
@@ -128,7 +128,7 @@ export declare function unwrapReadOutput(output: string): string;
  * OpenCode returns free-form text; we wrap it in the minimal success shape the
  * server accepts (verified against agent.v1 wire captures).
  */
-export declare function buildTypedExecResult(resultField: string, output: string, error?: string, toolName?: string, resultMetadata?: Record<string, unknown>): Record<string, unknown>;
+export declare function buildTypedExecResult(resultField: string, output: string, error?: string, toolName?: string, resultMetadata?: Record<string, unknown>, shellOutcome?: CursorShellOutcome): Record<string, unknown>;
 export declare function buildToolCallPart(execMsg: ParsedExecRequest, sessionId: string): {
     toolCallId: string;
     toolName: string;