cursor-opencode-provider 0.6.4 → 0.6.7

package/dist/protocol/tools.js

@@ -6,7 +6,7 @@ import { encodeJsonAsValue, decodeStructEntriesToJson, readAllFields } from "./s
 import { buildEnv } from "../context/env.js";
 import { ensureOpencodeProjectDir } from "../context/paths.js";
 import { trace, traceRequestContextPaths } from "../debug.js";
-import { cursorExecVariantByRequestName } from "./exec-variants.js";
+import { cursorExecVariantByRequestName, FORCE_BACKGROUND_STATUS_ERROR, } from "./exec-variants.js";
 import { APPLY_PATCH_TOOL, buildAddFilePatch, buildUpdateFilePatch, planSubstringEdit, } from "./apply-patch.js";
 import { BACKGROUND_SHELL_MARKER, buildBackgroundShellCommand, } from "../shell-timeout.js";
 // Exec variant field number whose reply is the server-initiated request_context
@@ -233,6 +233,8 @@ export function buildLiveRequestContext(tools, providerIdentifier = "opencode",
 // does not. This provider intentionally remaps:
 //   - delete_args → bash `rm -f -- <quoted-path>`
 //   - background_shell_spawn_args → bash (original command; plugin wraps nohup)
+//   - shell_args (#2) → bash, same timeout/background path as shell_stream; the
+//     reply stays ShellResult (not the streaming oneof).
 // Permissions still flow through OpenCode's advertised `bash` tool. Soft-
 // background / detached children can outlive the OpenCode tool call; leftover
 // process cleanup is left to the user / OS. Arg key remapping happens below.
@@ -249,6 +251,7 @@ const cursorToolToOpencode = {
     grep_args: "grep",
     ls_args: "read",
     delete_args: "bash",
+    shell_args: "bash",
     shell_stream_args: "bash",
     background_shell_spawn_args: "bash",
     subagent_args: "task",
@@ -793,7 +796,7 @@ export function parseExecServerMessage(msg) {
         "pi_read_args", "pi_bash_args", "pi_edit_args", "pi_write_args",
         "pi_grep_args", "pi_find_args", "pi_ls_args",
         "grep_args", "ls_args",
-        "delete_args", "shell_stream_args", "background_shell_spawn_args", "mcp_args",
+        "delete_args", "shell_args", "shell_stream_args", "background_shell_spawn_args", "mcp_args",
         "subagent_args",
     ]);
     if (!execVariant)
@@ -915,7 +918,7 @@ export function parseExecServerMessage(msg) {
         return undefined;
     const mapped = mapCursorArgsToOpencode(toolName, msg[execVariant] ?? {}, execVariant);
     const rawArgs = msg[execVariant] ?? {};
-    const resultMetadata = execVariant === "shell_stream_args"
+    const resultMetadata = execVariant === "shell_stream_args" || execVariant === "shell_args"
         ? shellStreamResultMetadata(rawArgs)
         : execVariant === "read_args"
             ? {
@@ -1412,6 +1415,164 @@ export function buildExecStreamClose(execId) {
         },
     });
 }
+export function buildUnsupportedExecDeny(input) {
+    const { execId, variant, reason } = input;
+    const resultName = variant.resultName;
+    const frames = [];
+    const throwFrame = (msg) => encodeMessage("AgentClientMessage", {
+        exec_client_control_message: {
+            throw: { id: execId, error: msg },
+        },
+    });
+    switch (resultName) {
+        case "shell_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    shell_result: { rejected: { reason } },
+                },
+            }));
+            break;
+        case "diagnostics_result":
+        case "canvas_diagnostics_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    [resultName]: { error: { path: "", error: reason } },
+                },
+            }));
+            break;
+        case "fetch_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    fetch_result: { error: { url: "", error: reason } },
+                },
+            }));
+            break;
+        case "record_screen_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    record_screen_result: { failure: { error: reason } },
+                },
+            }));
+            break;
+        case "computer_use_result":
+        case "write_shell_stdin_result":
+        case "smart_mode_classifier_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    [resultName]: { error: { error: reason } },
+                },
+            }));
+            break;
+        case "redacted_read_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    redacted_read_result: { error: { path: "", error: reason } },
+                },
+            }));
+            break;
+        case "subagent_await_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    subagent_await_result: { error: { error: reason } },
+                },
+            }));
+            break;
+        case "shell_allowlist_precheck_result":
+        case "mcp_allowlist_precheck_result":
+        case "web_fetch_allowlist_precheck_result":
+            // Typed precheck result is a bool, not a reason string. Encoding
+            // `{allowlisted:false}` selects the ExecClientMessage oneof; protobufjs
+            // writes field 1 as varint 0 so Cursor decodes the deny rather than an
+            // empty/unspecified precheck.
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    [resultName]: { allowlisted: false },
+                },
+            }));
+            break;
+        case "force_background_shell_result":
+        case "force_background_subagent_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    [resultName]: { status: FORCE_BACKGROUND_STATUS_ERROR },
+                },
+            }));
+            break;
+        case "mini_swe_agent_bash_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    mini_swe_agent_bash_result: { rejected: { reason } },
+                },
+            }));
+            break;
+        case "conversation_search_result":
+            // No local Cursor conversation index. Empty success is truthful and
+            // avoids a retry loop; the model can continue with listed tools.
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    conversation_search_result: {
+                        success: { hits: [], truncated: false, partial: false, rebuilding: false },
+                    },
+                },
+            }));
+            break;
+        case "agent_store_conflict_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    agent_store_conflict_result: { error: { error: reason } },
+                },
+            }));
+            break;
+        case "adopt_result":
+            frames.push(encodeMessage("AgentClientMessage", {
+                exec_client_message: {
+                    id: execId,
+                    local_execution_time_ms: 0,
+                    adopt_result: { error: reason },
+                },
+            }));
+            break;
+        case "execute_hook_result":
+            // agent.proto has no populated error oneof we can emit;
+            // Cursor CLI answers this through exec_client_control_message.throw.
+            frames.push(throwFrame(reason));
+            frames.push(buildExecStreamClose(execId));
+            return frames;
+        default:
+            // Fallback for any future unsupported variant without a dedicated shape:
+            // typed error when possible, else throw. Unknown shapes should hard-fail
+            // at the pump, so this path is not expected for known unsupported rows.
+            frames.push(throwFrame(reason));
+            frames.push(buildExecStreamClose(execId));
+            return frames;
+    }
+    frames.push(buildExecStreamClose(execId));
+    return frames;
+}
 /**
  * Strip opencode's `read` envelope, leaving raw file content.
  *
@@ -1570,6 +1731,58 @@ export function buildTypedExecResult(resultField, output, error, toolName, resul
             const truncation = readTruncationMessage(output, content);
             return { success: { output: content, ...(truncation ? { truncation } : {}) } };
         }
+        case "shell_result": {
+            const command = str(resultMetadata?.command) ?? "";
+            const workingDirectory = str(resultMetadata?.working_directory) ?? "";
+            if (error) {
+                return {
+                    failure: {
+                        command,
+                        working_directory: workingDirectory,
+                        exit_code: 1,
+                        stdout: output || "",
+                        stderr: error,
+                        aborted: false,
+                    },
+                };
+            }
+            if (shellOutcome?.kind === "timeout") {
+                return {
+                    timeout: {
+                        command,
+                        working_directory: workingDirectory,
+                        timeout_ms: shellOutcome.timeoutMs,
+                    },
+                };
+            }
+            if (shellOutcome?.kind === "backgrounded") {
+                return {
+                    success: {
+                        command: shellOutcome.command || command,
+                        working_directory: shellOutcome.workingDirectory || workingDirectory,
+                        exit_code: 0,
+                        stdout: output,
+                        shell_id: shellOutcome.shellId,
+                        pid: shellOutcome.pid,
+                        ms_to_wait: shellOutcome.msToWait,
+                        background_reason: shellOutcome.reason,
+                    },
+                    is_background: true,
+                    pid: shellOutcome.pid,
+                };
+            }
+            const exitCode = shellOutcome?.kind === "exit"
+                ? Math.max(0, Math.min(0xffff_ffff, shellOutcome.code))
+                : 0;
+            return {
+                success: {
+                    command,
+                    working_directory: workingDirectory,
+                    exit_code: exitCode,
+                    stdout: output,
+                },
+            };
+        }
         case "pi_bash_result":
         case "pi_edit_result":
         case "pi_grep_result":

package/dist/protocol/workspace-grounding.d.ts

@@ -0,0 +1 @@
+export declare function appendWorkspaceRootGrounding(reason: string, workspaceRoot: string | undefined): string;

package/dist/protocol/workspace-grounding.js

@@ -0,0 +1,8 @@
+export function appendWorkspaceRootGrounding(reason, workspaceRoot) {
+    if (!workspaceRoot || !workspaceRoot.trim())
+        return reason;
+    if (reason.includes("Workspace root:"))
+        return reason;
+    return (`${reason}\nWorkspace 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.");
+}

package/dist/session.d.ts

@@ -175,8 +175,9 @@ export type CursorSession = {
      */
     allowTools: boolean;
     /**
-     * Best-effort held-Run activity counters used only for diagnostics. AI SDK
-     * accounting comes from the request-local final TurnEnded, never this estimate.
+     * Best-effort held-Run activity counters used only for diagnostics. Displayed
+     * AI SDK usage comes from checkpoint occupancy (tool steps) and TurnEnded
+     * (stop); this estimate is never sent to OpenCode.
      */
     usageEstimate: {
         inputTokens: number;
@@ -207,6 +208,7 @@ export type CursorSession = {
     semanticDeadlineAt: number;
     closeError: CursorProviderError | null;
     closed: boolean;
+    reopenWithUserMessage?: (text: string) => Promise<void>;
 };
 type SessionManagerOptions = {
     now?: () => number;
@@ -255,6 +257,13 @@ export declare class SessionManager {
     beginPump(session: CursorSession, owner: symbol): void;
     isPumpOwner(session: CursorSession, owner: symbol): boolean;
     endPump(session: CursorSession, owner: symbol): boolean;
+    /**
+     * Swap the live bidi Run while a pump is still pulling frames.
+     * Callers must cancel the session heartbeat and wait for the old stream's
+     * write chain before this, so an in-flight heartbeat cannot close the session.
+     */
+    replaceStream(session: CursorSession, next: BidiStream): void;
+    private subscribeTerminal;
     private key;
     close(session: CursorSession, reason?: SessionCloseReason, error?: CursorProviderError): void;
     /**

package/dist/session.js

@@ -118,11 +118,7 @@ export class SessionManager {
             this.byOpenCodeSessionId.set(session.openCodeSessionId, session);
         }
         this.enforceOpenSessionCap(session);
-        const unsubscribe = session.stream.onTerminal?.((event) => this.onStreamTerminal(session, event)) ?? (() => { });
-        if (session.closed)
-            unsubscribe();
-        else
-            session.terminalUnsubscribe = unsubscribe;
+        this.subscribeTerminal(session);
     }
     isPumping(session) {
         return session.pumpOwner != null || session.pumpActive;
@@ -325,6 +321,39 @@ export class SessionManager {
             this.close(session, deferred);
         return true;
     }
+    /**
+     * Swap the live bidi Run while a pump is still pulling frames.
+     * Callers must cancel the session heartbeat and wait for the old stream's
+     * write chain before this, so an in-flight heartbeat cannot close the session.
+     */
+    replaceStream(session, next) {
+        if (session.closed)
+            throw new CursorProtocolError("Cannot replace stream on a closed Cursor session");
+        session.heartbeatCancel?.();
+        session.terminalUnsubscribe?.();
+        session.terminalUnsubscribe = null;
+        session.deferredTerminalReason = null;
+        const old = session.stream;
+        session.stream = next;
+        session.frames = next.frames()[Symbol.asyncIterator]();
+        this.subscribeTerminal(session);
+        try {
+            old.destroy();
+        }
+        catch { /* already closed */ }
+    }
+    subscribeTerminal(session) {
+        const boundStream = session.stream;
+        const unsubscribe = boundStream.onTerminal?.((event) => {
+            if (session.stream !== boundStream)
+                return;
+            this.onStreamTerminal(session, event);
+        }) ?? (() => { });
+        if (session.closed)
+            unsubscribe();
+        else
+            session.terminalUnsubscribe = unsubscribe;
+    }
     key(sessionId, execId) {
         return `${sessionId}:${execId}`;
     }

package/dist/usage.d.ts

@@ -51,6 +51,20 @@ export declare function formatCursorCacheDiagnostics(counters: CursorUsageCounte
 export declare function formatTurnUsageValidation(counters: CursorUsageCounters, usage: LanguageModelV3Usage, tokenDetails?: CursorConversationTokenDetails, contextSource?: CursorContextUsageSource): string;
 /** OpenCode requires a usage object at every step boundary. */
 export declare function emptyLanguageModelV3Usage(): LanguageModelV3Usage;
+/**
+ * OpenCode TUI/GUI replace each assistant message's `tokens` (they do not sum
+ * occupancy). The TUI footer picks the last assistant with `tokens.output > 0`.
+ * Session cost, however, adds every step-finish. Checkpoint occupancy is
+ * therefore sent as a snapshot with `output=1` so the footer accepts it, and
+ * callers attach {@link OPENCODE_DISPLAY_ONLY_COST_METADATA} so getUsage
+ * reports $0 instead of billing the snapshot as a new prompt.
+ */
+export declare const OPENCODE_DISPLAY_ONLY_COST_METADATA: {
+    readonly copilot: {
+        readonly totalNanoAiu: 0;
+    };
+};
+export declare function occupancyUsageFromTokenDetails(details: CursorConversationTokenDetails, prior?: CursorConversationTokenDetails): LanguageModelV3Usage;
 /** Project nested V3 usage into the common flat AI-SDK counter shape. */
 export declare function flatUsageFromV3(usage: LanguageModelV3Usage): {
     inputTokens: number;

package/dist/usage.js

@@ -229,6 +229,32 @@ export function emptyLanguageModelV3Usage() {
         reasoningTokens: 0,
     });
 }
+/**
+ * OpenCode TUI/GUI replace each assistant message's `tokens` (they do not sum
+ * occupancy). The TUI footer picks the last assistant with `tokens.output > 0`.
+ * Session cost, however, adds every step-finish. Checkpoint occupancy is
+ * therefore sent as a snapshot with `output=1` so the footer accepts it, and
+ * callers attach {@link OPENCODE_DISPLAY_ONLY_COST_METADATA} so getUsage
+ * reports $0 instead of billing the snapshot as a new prompt.
+ */
+export const OPENCODE_DISPLAY_ONLY_COST_METADATA = {
+    copilot: { totalNanoAiu: 0 },
+};
+export function occupancyUsageFromTokenDetails(details, prior) {
+    const used = Math.max(0, Math.trunc(details.usedTokens));
+    if (used <= 0)
+        return emptyLanguageModelV3Usage();
+    return buildLanguageModelV3UsageFromCounters({
+        inputTokens: used,
+        outputTokens: 1,
+        cacheRead: prior?.usedTokens ?? 0,
+        cacheWrite: 0,
+        reasoningTokens: 0,
+    }, {
+        contextTotalTokens: used,
+        priorContextTokens: prior?.usedTokens,
+    });
+}
 /** Project nested V3 usage into the common flat AI-SDK counter shape. */
 export function flatUsageFromV3(usage) {
     const input = usage.inputTokens;

package/package.json

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