cursor-opencode-provider 0.2.1 → 0.2.3

package/dist/protocol/tools.d.ts

@@ -4,28 +4,45 @@ export type OpencodeToolDef = {
     description?: string;
     inputSchema?: unknown;
 };
+export type ToolServerIdentity = {
+    /** Cursor MCP server id / provider_identifier (e.g. opencode, github). */
+    server: string;
+    /** Bare tool name inside that server (Cursor McpArgs.tool_name). */
+    toolName: string;
+    /** Full OpenCode tool id used for local execution (e.g. github_create_pull_request). */
+    opencodeName: string;
+};
+/** Match OpenCode's McpCatalog.sanitize for config server ids. */
+export declare function sanitizeMcpServerId(value: string): string;
+/**
+ * Resolve an OpenCode tool id using known MCP server ids from merged config.
+ * Unknown names remain under the synthetic default server: a flattened tool
+ * name alone cannot distinguish plugin/custom tools from `<server>_<tool>`.
+ */
+export declare function resolveToolServerIdentity(opencodeName: string, defaultServer?: string, knownMcpServers?: Iterable<string>): ToolServerIdentity;
 /**
  * Convert opencode's per-turn tool list into Cursor `McpToolDefinition`
  * entries for `request_context.tools` (#7) and `AgentRunRequest.mcp_tools`.
  *
- * opencode tools are already namespaced (e.g. `read`, `grep`, or
- * `<server>_<tool>` for MCP). We advertise them all under a synthetic
- * `opencode` provider so Cursor routes their calls back to us as
- * `mcp_args` on the exec channel. The composite `name` is what the model
- * calls and what comes back as `McpArgs.name`.
+ * Builtins and unknown plugin/custom tools are advertised under the synthetic
+ * default server (`opencode`). Tools whose prefixes match configured MCP
+ * servers keep those server ids (`github`, …). Composite `name` is
+ * `<server>-<bareTool>`; local execution still uses the full OpenCode id
+ * reconstructed in `mcpRealToolName`.
  */
-export declare function toolsToDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string): Array<Record<string, unknown>>;
+export declare function toolsToDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>): Array<Record<string, unknown>>;
 /**
  * Build the nested McpFileSystemOptions / McpMetaToolOptions shape used by
- * requestContext.#23 / #34. Groups every tool under one synthetic server so
- * Cursor's IDE-style decoder also sees the list.
+ * requestContext.#23 / #34. One `McpDescriptor` per resolved server (builtins
+ * and unknown tools under the synthetic default; configured MCP tools under
+ * their upstream server id).
  */
-export declare function toolsToMcpDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string): Array<Record<string, unknown>>;
+export declare function toolsToMcpDescriptors(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>): Array<Record<string, unknown>>;
 /**
  * @deprecated Prefer `buildRequestContext` from `../context/build.js`.
  * Kept as a sync tools-only fallback for unit tests that don't need collectors.
  */
-export declare function buildLiveRequestContext(tools: OpencodeToolDef[], providerIdentifier?: string): Record<string, unknown>;
+export declare function buildLiveRequestContext(tools: OpencodeToolDef[], providerIdentifier?: string, knownMcpServers?: Iterable<string>): Record<string, unknown>;
 export declare function mapExecServerToToolName(execField: string): string | undefined;
 export declare function mapToolNameToExecField(toolName: string): string | undefined;
 export type ParsedExecRequest = {
@@ -35,6 +52,8 @@ export type ParsedExecRequest = {
     args: Record<string, unknown>;
     /** ExecClientMessage result field to reply with (matches the request variant). */
     resultField: string;
+    /** Typed error to return without asking OpenCode to execute invalid args. */
+    localError?: string;
 };
 export declare function parseExecServerMessage(msg: Record<string, unknown>): ParsedExecRequest | undefined;
 /**
@@ -46,6 +65,12 @@ export declare function mapCursorArgsToOpencode(toolName: string, raw: Record<st
     toolName: string;
     args: Record<string, unknown>;
 };
+/**
+ * Map Cursor McpArgs back to the OpenCode tool id.
+ * Prefers provider_identifier + bare tool_name (github + create_pull_request
+ * → github_create_pull_request). Builtins under the default server stay bare.
+ */
+export declare function mcpRealToolName(mcpArgs: Record<string, unknown>, defaultServer?: string): string;
 export type ToolResultInput = {
     execId: number;
     /** ExecClientMessage result field (from ParsedExecRequest.resultField). */
@@ -113,9 +138,13 @@ export declare function parseExecIdFromToolCallId(toolCallId: string): {
  * Returns undefined if there is no exec_server_message or no variant set.
  */
 export declare function detectExecVariantField(agentServerPayload: Uint8Array): number | undefined;
-/** Build ExecClientMessage{1:id, <resultField>: empty} as raw bytes. */
-export declare function buildRawEmptyExecReply(execId: number, resultField: number): Uint8Array;
 /**
  * Encode exec #10 request_context_result from a prebuilt RequestContext payload.
  */
 export declare function buildRequestContextResult(execId: number, requestContext: Record<string, unknown>): Uint8Array;
+/**
+ * Answer Cursor's exec #36 MCP-state probe from the same descriptors advertised
+ * in RequestContext. OpenCode remains the executor; this only confirms that the
+ * provider's virtual MCP servers and their tools are available.
+ */
+export declare function buildMcpStateResult(execId: number, args: Record<string, unknown>, requestContext: Record<string, unknown>): Uint8Array;

package/dist/protocol/tools.js

@@ -5,24 +5,56 @@ import { trace } from "../debug.js";
 // probe (ExecServerMessage #10 → ExecClientMessage #10). request/result share a
 // field number for every exec variant, so this is also the result field.
 export const REQUEST_CONTEXT_RESULT_FIELD = 10;
+/** Match OpenCode's McpCatalog.sanitize for config server ids. */
+export function sanitizeMcpServerId(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+/**
+ * Resolve an OpenCode tool id using known MCP server ids from merged config.
+ * Unknown names remain under the synthetic default server: a flattened tool
+ * name alone cannot distinguish plugin/custom tools from `<server>_<tool>`.
+ */
+export function resolveToolServerIdentity(opencodeName, defaultServer = "opencode", knownMcpServers = []) {
+    if (!opencodeName) {
+        return { server: defaultServer, toolName: "mcp", opencodeName: "mcp" };
+    }
+    // Longest first handles configured ids where one is a prefix of another
+    // (e.g. "git" and "git_hub"). OpenCode flattens with the sanitized id.
+    const servers = [...new Set([...knownMcpServers].map(sanitizeMcpServerId).filter(Boolean))]
+        .sort((a, b) => b.length - a.length);
+    for (const server of servers) {
+        const prefix = `${server}_`;
+        if (!opencodeName.startsWith(prefix) || opencodeName.length === prefix.length)
+            continue;
+        return {
+            server,
+            toolName: opencodeName.slice(prefix.length),
+            opencodeName,
+        };
+    }
+    return { server: defaultServer, toolName: opencodeName, opencodeName };
+}
 /**
  * Convert opencode's per-turn tool list into Cursor `McpToolDefinition`
  * entries for `request_context.tools` (#7) and `AgentRunRequest.mcp_tools`.
  *
- * opencode tools are already namespaced (e.g. `read`, `grep`, or
- * `<server>_<tool>` for MCP). We advertise them all under a synthetic
- * `opencode` provider so Cursor routes their calls back to us as
- * `mcp_args` on the exec channel. The composite `name` is what the model
- * calls and what comes back as `McpArgs.name`.
+ * Builtins and unknown plugin/custom tools are advertised under the synthetic
+ * default server (`opencode`). Tools whose prefixes match configured MCP
+ * servers keep those server ids (`github`, …). Composite `name` is
+ * `<server>-<bareTool>`; local execution still uses the full OpenCode id
+ * reconstructed in `mcpRealToolName`.
  */
-export function toolsToDescriptors(tools, providerIdentifier = "opencode") {
-    return tools.map((t) => ({
-        name: `${providerIdentifier}-${t.name}`,
-        description: t.description ?? "",
-        input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
-        provider_identifier: providerIdentifier,
-        tool_name: t.name,
-    }));
+export function toolsToDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = []) {
+    return tools.map((t) => {
+        const id = resolveToolServerIdentity(t.name, providerIdentifier, knownMcpServers);
+        return {
+            name: `${id.server}-${id.toolName}`,
+            description: t.description ?? "",
+            input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
+            provider_identifier: id.server,
+            tool_name: id.toolName,
+        };
+    });
 }
 function normalizeInputSchema(schema) {
     if (schema && typeof schema === "object" && !Array.isArray(schema)) {
@@ -32,31 +64,42 @@ function normalizeInputSchema(schema) {
 }
 /**
  * Build the nested McpFileSystemOptions / McpMetaToolOptions shape used by
- * requestContext.#23 / #34. Groups every tool under one synthetic server so
- * Cursor's IDE-style decoder also sees the list.
+ * requestContext.#23 / #34. One `McpDescriptor` per resolved server (builtins
+ * and unknown tools under the synthetic default; configured MCP tools under
+ * their upstream server id).
  */
-export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode") {
+export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = []) {
     if (tools.length === 0)
         return [];
-    return [
-        {
-            server_name: providerIdentifier,
-            server_identifier: providerIdentifier,
-            tools: tools.map((t) => ({
-                tool_name: t.name,
-                description: t.description ?? "",
-                input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
-            })),
-        },
-    ];
+    const order = [];
+    const byServer = new Map();
+    for (const t of tools) {
+        const id = resolveToolServerIdentity(t.name, providerIdentifier, knownMcpServers);
+        let list = byServer.get(id.server);
+        if (!list) {
+            list = [];
+            byServer.set(id.server, list);
+            order.push(id.server);
+        }
+        list.push({
+            tool_name: id.toolName,
+            description: t.description ?? "",
+            input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
+        });
+    }
+    return order.map((server) => ({
+        server_name: server,
+        server_identifier: server,
+        tools: byServer.get(server),
+    }));
 }
 /**
  * @deprecated Prefer `buildRequestContext` from `../context/build.js`.
  * Kept as a sync tools-only fallback for unit tests that don't need collectors.
  */
-export function buildLiveRequestContext(tools, providerIdentifier = "opencode") {
-    const flat = toolsToDescriptors(tools, providerIdentifier);
-    const nested = toolsToMcpDescriptors(tools, providerIdentifier);
+export function buildLiveRequestContext(tools, providerIdentifier = "opencode", knownMcpServers = []) {
+    const flat = toolsToDescriptors(tools, providerIdentifier, knownMcpServers);
+    const nested = toolsToMcpDescriptors(tools, providerIdentifier, knownMcpServers);
     const cwd = process.cwd();
     return {
         env: {
@@ -94,7 +137,13 @@ export function buildLiveRequestContext(tools, providerIdentifier = "opencode")
 const cursorToolToOpencode = {
     read_args: "read",
     write_args: "write",
+    pi_read_args: "read",
+    pi_bash_args: "bash",
+    pi_edit_args: "edit",
     pi_write_args: "write",
+    pi_grep_args: "grep",
+    pi_find_args: "glob",
+    pi_ls_args: "read",
     grep_args: "grep",
     ls_args: "read",
     delete_args: "bash",
@@ -137,6 +186,17 @@ const CURSOR_INTERNAL_KEYS = new Set([
     "encoding_hint",
     "ignore",
 ]);
+/** Required content fields where an empty string is meaningful (for example, truncating a file). */
+const PRESERVE_EMPTY_STRING_KEYS = new Set([
+    "content",
+    "file_text",
+    "fileText",
+    "stream_content",
+    "oldString",
+    "old_string",
+    "newString",
+    "new_string",
+]);
 export function mapExecServerToToolName(execField) {
     return cursorToolToOpencode[execField];
 }
@@ -150,22 +210,28 @@ export function mapToolNameToExecField(toolName) {
 const execVariantToResultField = {
     read_args: "read_result",
     write_args: "write_result",
-    // Pi write: args #48, result #49 (not the same field number).
+    pi_read_args: "pi_read_result",
+    pi_bash_args: "pi_bash_result",
+    pi_edit_args: "pi_edit_result",
     pi_write_args: "pi_write_result",
+    pi_grep_args: "pi_grep_result",
+    pi_find_args: "pi_find_result",
+    pi_ls_args: "pi_ls_result",
     grep_args: "grep_result",
     ls_args: "ls_result",
     delete_args: "delete_result",
     shell_stream_args: "shell_stream",
     mcp_args: "mcp_result",
 };
-const MCP_PREFIX = "opencode-";
 export function parseExecServerMessage(msg) {
     const id = msg.id;
     if (id === undefined)
         return undefined;
     // Find which args variant is set
     const execVariant = findOneOfVariant(msg, [
-        "read_args", "write_args", "pi_write_args",
+        "read_args", "write_args",
+        "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", "mcp_args",
     ]);
@@ -187,6 +253,33 @@ export function parseExecServerMessage(msg) {
             resultField,
         };
     }
+    if (execVariant === "pi_edit_args") {
+        const raw = msg.pi_edit_args ?? {};
+        const edits = Array.isArray(raw.edits) ? raw.edits : [];
+        const replacement = edits.length === 1 && edits[0] && typeof edits[0] === "object"
+            ? edits[0]
+            : undefined;
+        const path = str(raw.path);
+        const oldString = replacement ? stringValue(replacement.old_text) : undefined;
+        const newString = replacement ? stringValue(replacement.new_text) : undefined;
+        const args = {};
+        if (path)
+            args.filePath = path;
+        if (oldString !== undefined)
+            args.oldString = oldString;
+        if (newString !== undefined)
+            args.newString = newString;
+        return {
+            id,
+            execId,
+            toolName: "edit",
+            args,
+            resultField,
+            localError: path && oldString && newString !== undefined
+                ? undefined
+                : "Cursor Pi edit cannot be represented safely: expected one non-empty replacement.",
+        };
+    }
     const toolName = cursorToolToOpencode[execVariant];
     if (!toolName)
         return undefined;
@@ -211,8 +304,9 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
             continue;
         if (CURSOR_INTERNAL_KEYS.has(k))
             continue;
-        // Drop empty strings from optional protobuf defaults.
-        if (typeof v === "string" && v.length === 0)
+        // Drop empty strings from optional protobuf defaults, but retain required
+        // content fields where empty means a valid destructive edit/write.
+        if (typeof v === "string" && v.length === 0 && !PRESERVE_EMPTY_STRING_KEYS.has(k))
             continue;
         cleaned[k] = v;
     }
@@ -250,7 +344,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
             if (filePath)
                 args.filePath = filePath;
-            const content = str(cleaned.content) ?? str(cleaned.file_text) ?? str(cleaned.fileText);
+            const content = stringValue(cleaned.content) ?? stringValue(cleaned.file_text) ?? stringValue(cleaned.fileText);
             if (content !== undefined)
                 args.content = content;
             return { toolName: "write", args };
@@ -260,10 +354,10 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
             if (filePath)
                 args.filePath = filePath;
-            const oldString = str(cleaned.oldString) ?? str(cleaned.old_string);
+            const oldString = stringValue(cleaned.oldString) ?? stringValue(cleaned.old_string);
             if (oldString !== undefined)
                 args.oldString = oldString;
-            const newString = str(cleaned.newString) ?? str(cleaned.new_string);
+            const newString = stringValue(cleaned.newString) ?? stringValue(cleaned.new_string);
             if (newString !== undefined)
                 args.newString = newString;
             if (typeof cleaned.replaceAll === "boolean")
@@ -321,6 +415,9 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
 function str(v) {
     return typeof v === "string" && v.length > 0 ? v : undefined;
 }
+function stringValue(v) {
+    return typeof v === "string" ? v : undefined;
+}
 function num(v) {
     if (typeof v === "number" && Number.isFinite(v))
         return v;
@@ -331,12 +428,35 @@ function num(v) {
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function mcpRealToolName(mcpArgs) {
-    const toolName = mcpArgs.tool_name;
-    if (toolName)
+/**
+ * Map Cursor McpArgs back to the OpenCode tool id.
+ * Prefers provider_identifier + bare tool_name (github + create_pull_request
+ * → github_create_pull_request). Builtins under the default server stay bare.
+ */
+export function mcpRealToolName(mcpArgs, defaultServer = "opencode") {
+    const toolName = typeof mcpArgs.tool_name === "string" ? mcpArgs.tool_name : undefined;
+    const provider = typeof mcpArgs.provider_identifier === "string" ? mcpArgs.provider_identifier : undefined;
+    if (toolName) {
+        if (provider && provider !== defaultServer) {
+            // Already a full OpenCode id (legacy ads or model echo).
+            if (toolName.startsWith(`${provider}_`))
+                return toolName;
+            return `${provider}_${toolName}`;
+        }
         return toolName;
-    const name = mcpArgs.name ?? "";
-    return name.startsWith(MCP_PREFIX) ? name.slice(MCP_PREFIX.length) : name || "mcp";
+    }
+    const name = typeof mcpArgs.name === "string" ? mcpArgs.name : "";
+    const dash = name.indexOf("-");
+    if (dash > 0) {
+        const server = name.slice(0, dash);
+        const bare = name.slice(dash + 1);
+        if (server && bare) {
+            if (server === defaultServer)
+                return bare;
+            return `${server}_${bare}`;
+        }
+    }
+    return name || "mcp";
 }
 function decodeMcpArgs(raw) {
     if (!Array.isArray(raw))
@@ -537,6 +657,18 @@ export function buildTypedExecResult(resultField, output, error, toolName) {
             if (error)
                 return { error: { error } };
             return { success: { output: output || "Wrote file successfully." } };
+        case "pi_read_result":
+            if (error)
+                return { error: { error } };
+            return { success: { output: unwrapReadOutput(output) } };
+        case "pi_bash_result":
+        case "pi_edit_result":
+        case "pi_grep_result":
+        case "pi_find_result":
+        case "pi_ls_result":
+            if (error)
+                return { error: { error } };
+            return { success: { output } };
         case "delete_result":
             if (error)
                 return { error: { path: "", error } };
@@ -639,15 +771,11 @@ export function parseExecIdFromToolCallId(toolCallId) {
         return undefined;
     return { sessionId: match[1], execId };
 }
-// ── Safety net: reply to exec variants we don't map to an opencode tool ──
+// ── Unknown exec diagnostics ──
 //
-// Cursor's real server sends server-initiated exec probes (request_context #10,
-// and potentially diagnostics/smart-mode-classifier/etc.) that are NOT tool
-// calls. opencode owns the tool loop, so these have no opencode tool to route
-// to — but we MUST still reply on the Run stream or the server blocks forever
-// (endless heartbeats, no response). For any unmapped variant we emit an empty
-// result at the SAME field number (request/result field numbers are identical
-// for every exec variant: read #7→#7, mcp #11→#11, request_context #10→#10…).
+// Request/result field numbers are not universally identical (the Pi range is
+// offset by one), so unknown variants must never receive a guessed empty reply.
+// The pump uses this raw detector to report schema drift and fail the Run.
 /**
  * Find the exec variant field number from the raw (gunzipped) AgentServerMessage
  * payload: peel field #2 (exec_server_message), then return the first
@@ -667,29 +795,6 @@ export function detectExecVariantField(agentServerPayload) {
     }
     return undefined;
 }
-/** Build ExecClientMessage{1:id, <resultField>: empty} as raw bytes. */
-export function buildRawEmptyExecReply(execId, resultField) {
-    const inner = [];
-    writeVarintRaw(inner, (1 << 3) | 0); // field 1 (id), wire 0 (varint)
-    writeVarintRaw(inner, execId >>> 0);
-    writeVarintRaw(inner, (resultField << 3) | 2); // field N, wire 2 (length-delimited)
-    writeVarintRaw(inner, 0); // empty submessage
-    // Wrap as AgentClientMessage.exec_client_message (field #2).
-    const acm = [];
-    writeVarintRaw(acm, (2 << 3) | 2);
-    writeVarintRaw(acm, inner.length);
-    for (const b of inner)
-        acm.push(b);
-    return new Uint8Array(acm);
-}
-function writeVarintRaw(out, n) {
-    let v = n >>> 0;
-    while (v > 0x7f) {
-        out.push((v & 0x7f) | 0x80);
-        v >>>= 7;
-    }
-    out.push(v);
-}
 /**
  * Encode exec #10 request_context_result from a prebuilt RequestContext payload.
  */
@@ -705,3 +810,62 @@ export function buildRequestContextResult(execId, requestContext) {
         },
     });
 }
+/**
+ * Answer Cursor's exec #36 MCP-state probe from the same descriptors advertised
+ * in RequestContext. OpenCode remains the executor; this only confirms that the
+ * provider's virtual MCP servers and their tools are available.
+ */
+export function buildMcpStateResult(execId, args, requestContext) {
+    const requested = new Set(Array.isArray(args.server_identifiers)
+        ? args.server_identifiers.filter((id) => typeof id === "string" && id.length > 0)
+        : []);
+    const fsOptions = recordValue(requestContext.mcp_file_system_options);
+    const nested = Array.isArray(fsOptions?.mcp_descriptors)
+        ? fsOptions.mcp_descriptors.map(recordValue).filter((d) => !!d)
+        : [];
+    const descriptors = nested.length > 0 ? nested : descriptorsFromFlatTools(requestContext.tools);
+    const servers = descriptors
+        .filter((descriptor) => {
+        const id = stringValue(descriptor.server_identifier);
+        return requested.size === 0 || (id !== undefined && requested.has(id));
+    })
+        .map((descriptor) => ({
+        server_name: stringValue(descriptor.server_name) ?? stringValue(descriptor.server_identifier) ?? "",
+        server_identifier: stringValue(descriptor.server_identifier) ?? stringValue(descriptor.server_name) ?? "",
+        tools: Array.isArray(descriptor.tools) ? descriptor.tools : [],
+    }));
+    return encodeMessage("AgentClientMessage", {
+        exec_client_message: {
+            id: execId,
+            mcp_state_exec_result: { success: { servers } },
+        },
+    });
+}
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function descriptorsFromFlatTools(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byServer = new Map();
+    for (const raw of value) {
+        const tool = recordValue(raw);
+        if (!tool)
+            continue;
+        const server = stringValue(tool.provider_identifier) ?? "opencode";
+        const tools = byServer.get(server) ?? [];
+        tools.push({
+            tool_name: stringValue(tool.tool_name) ?? stringValue(tool.name) ?? "",
+            description: stringValue(tool.description) ?? "",
+            input_schema: tool.input_schema,
+        });
+        byServer.set(server, tools);
+    }
+    return [...byServer].map(([server, tools]) => ({
+        server_name: server,
+        server_identifier: server,
+        tools,
+    }));
+}

package/dist/session.d.ts

@@ -19,6 +19,12 @@ export type PendingExec = {
      * mcp_result can unwrap read envelopes even if the prompt omits toolName.
      */
     toolName?: string;
+    /**
+     * True when this pending entry was synthesized from a Cursor display-only
+     * tool_call_* frame (no ExecServerMessage). Continuation must not write an
+     * exec result back to Cursor — just clear pending and keep pumping.
+     */
+    bridged?: boolean;
 };
 export type CursorSession = {
     /**
@@ -35,6 +41,14 @@ export type CursorSession = {
     stream: BidiStream;
     frames: AsyncIterator<Frame>;
     pending: Map<number, PendingExec>;
+    /**
+     * Cursor display tool calls (tool_call_started) awaiting either an exec or a
+     * tool_call_completed. Keyed by call_id. Cleared when exec handles the call
+     * or when we bridge the completed display call into an OpenCode tool-call.
+     */
+    displayToolCalls: Map<string, Record<string, unknown>>;
+    /** Monotonic synthetic exec ids for bridged (display-only) OpenCode tool calls. */
+    nextBridgedExecId: number;
     /** KV blob store: blob_id (hex) → data, for Cursor's out-of-band payload channel. */
     blobs: Map<string, Uint8Array>;
     /** McpToolDefinition list advertised this turn — echoed into the request_context reply. */
@@ -47,6 +61,17 @@ export type CursorSession = {
      * stream instead of emitting tool-call parts OpenCode will reject.
      */
     allowTools: boolean;
+    /**
+     * Best-effort token usage for this held-open Run. Updated from text/tool
+     * activity and replaced by TurnEnded when the turn completes. Emitted on
+     * tool-calls finishes so OpenCode does not store all-zero usage mid-loop.
+     */
+    usageEstimate: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
     /**
      * True while a doStream pull() is actively reading this session's frames.
      * Prevents a late cancel/abort from a prior ReadableStream from destroying
@@ -63,7 +88,7 @@ export declare class SessionManager {
     constructor(idleTimeoutMs?: number);
     touch(session: CursorSession): void;
     /** Register that `session` is awaiting a result for `execId`. */
-    registerPending(execId: number, session: CursorSession, resultField: string, toolName?: string): void;
+    registerPending(execId: number, session: CursorSession, resultField: string, toolName?: string, bridged?: boolean): void;
     /** The pending exec info for an id on a specific session, if still awaiting it. */
     pendingFor(sessionId: string, execId: number): PendingExec | undefined;
     /** Find the live session awaiting one of the given exec ids. */

package/dist/session.js

@@ -12,8 +12,8 @@ export class SessionManager {
         session.expiresAt = Date.now() + this.idleTimeoutMs;
     }
     /** Register that `session` is awaiting a result for `execId`. */
-    registerPending(execId, session, resultField, toolName) {
-        session.pending.set(execId, { resultField, toolName });
+    registerPending(execId, session, resultField, toolName, bridged = false) {
+        session.pending.set(execId, { resultField, toolName, bridged });
         this.byExecId.set(this.key(session.sessionId, execId), session);
         this.touch(session);
     }

package/dist/shared.d.ts

@@ -2,6 +2,8 @@ export declare const CURSOR_API_HOST = "api2.cursor.sh";
 export declare const CURSOR_WEBSITE_HOST = "cursor.com";
 export declare const FALLBACK_CLIENT_VERSION = "cli-2026.07.09-a3815c0";
 export declare const CURSOR_PROVIDER_ID = "cursor";
+/** Private provider option injected by the OpenCode plugin for summary turns. */
+export declare const CURSOR_COMPACTION_OPTION = "opencodeCompaction";
 export declare const TOKEN_EXPIRY_THRESHOLD_S = 300;
 export declare const RUN_PATH = "/agent.v1.AgentService/Run";
 export declare const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";

package/dist/shared.js

@@ -2,6 +2,8 @@ export const CURSOR_API_HOST = "api2.cursor.sh";
 export const CURSOR_WEBSITE_HOST = "cursor.com";
 export const FALLBACK_CLIENT_VERSION = "cli-2026.07.09-a3815c0";
 export const CURSOR_PROVIDER_ID = "cursor";
+/** Private provider option injected by the OpenCode plugin for summary turns. */
+export const CURSOR_COMPACTION_OPTION = "opencodeCompaction";
 export const TOKEN_EXPIRY_THRESHOLD_S = 300;
 export const RUN_PATH = "/agent.v1.AgentService/Run";
 export const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -40,6 +40,7 @@
   "files": [
     "dist",
     "LICENSE",
+    "DISCLAIMER.md",
     "README.md"
   ],
   "scripts": {