cursor-opencode-provider 0.6.7 → 0.7.0

package/dist/plugin.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { CURSOR_COMPACTION_OPTION, CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
+import { CURSOR_API_HOST, CURSOR_COMPACTION_OPTION, CURSOR_HOST_AGENT_OPTION, CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, } from "./shared.js";
 import { cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled } from "./plugin-core.js";
 import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtExpiryMs } from "./auth.js";
 import { readCache, discoverModels, isCacheFresh } from "./models.js";
@@ -254,6 +254,10 @@ export async function CursorPlugin(input) {
         async "chat.params"(hookInput, output) {
             if (hookInput.model.providerID !== CURSOR_PROVIDER_ID)
                 return;
+            // Agent changes can replace the host system prompt and mode contract.
+            // Carry the canonical OpenCode id so an incompatible Cursor checkpoint
+            // is rotated instead of resuming the prior agent's prompt.
+            output.options[CURSOR_HOST_AGENT_OPTION] = hookInput.agent;
             // OpenCode's compaction pipeline invokes the LLM with agent="compaction".
             // Carry that stable runtime fact into LanguageModelV3 providerOptions so
             // the provider never has to guess from an empty tool list.

package/dist/protocol/conversation-persistence.d.ts

@@ -9,6 +9,8 @@ export type PersistedConversation = {
     requestContext: Record<string, unknown>;
     toolCatalog: OpencodeToolDef[];
     postCompactionRebase: boolean;
+    hostAgent?: string;
+    systemPromptHash?: string;
 };
 export type ConversationLoadStatus = "restored" | "missing" | "invalid" | "expired";
 export type PersistedConversationLoad = {

package/dist/protocol/conversation-persistence.js

@@ -47,7 +47,7 @@ function cloneConversation(value) {
  *
  * ConversationCache: schema_version=1, session_key=2, conversation_id=3,
  * updated_at=4, checkpoint=5, blobs=6, request_context=7, tool_catalog=8,
- * post_compaction_rebase=9.
+ * post_compaction_rebase=9, host_agent=10, system_prompt_hash=11.
  * Blob: id=1, data=2. Tool: name=1, description=2,
  * input_schema_json=3, source_name=4.
  *
@@ -172,6 +172,10 @@ function encodeCacheFile(value) {
     }
     if (value.postCompactionRebase)
         writer.uint32(fieldTag(9, 0)).bool(true);
+    if (value.hostAgent)
+        writer.uint32(fieldTag(10, 2)).string(value.hostAgent);
+    if (value.systemPromptHash)
+        writer.uint32(fieldTag(11, 2)).string(value.systemPromptHash);
     return { protobufBytes: writer.finish(), requestContextBytes: requestContext.length };
 }
 function decodeProtobuf(data) {
@@ -185,6 +189,8 @@ function decodeProtobuf(data) {
     let requestContextBytes;
     const toolCatalog = [];
     let postCompactionRebase = false;
+    let hostAgent;
+    let systemPromptHash;
     while (reader.pos < reader.len) {
         const tag = reader.uint32();
         const wireType = tag & 7;
@@ -234,6 +240,16 @@ function decodeProtobuf(data) {
                     throw new Error("invalid compaction marker");
                 postCompactionRebase = reader.bool();
                 break;
+            case 10:
+                if (wireType !== 2)
+                    throw new Error("invalid host agent");
+                hostAgent = reader.string();
+                break;
+            case 11:
+                if (wireType !== 2)
+                    throw new Error("invalid system prompt hash");
+                systemPromptHash = reader.string();
+                break;
             default:
                 reader.skipType(wireType);
         }
@@ -252,6 +268,8 @@ function decodeProtobuf(data) {
         requestContext,
         toolCatalog,
         postCompactionRebase,
+        ...(hostAgent ? { hostAgent } : {}),
+        ...(systemPromptHash ? { systemPromptHash } : {}),
     };
 }
 function decodeCacheFile(compressed, expectedSessionKey) {

package/dist/protocol/conversation-state.d.ts

@@ -4,6 +4,8 @@ export declare function hydrateConversationState(cacheDir: string, sessionKey: s
     conversationId: string;
     postCompactionRebase: boolean;
     toolCatalog: OpencodeToolDef[];
+    hostAgent?: string;
+    systemPromptHash?: string;
 } | undefined>;
 /** Persist the complete resumable state only after Cursor confirms TurnEnded. */
 export declare function persistConversationState(cacheDir: string, input: {
@@ -12,5 +14,7 @@ export declare function persistConversationState(cacheDir: string, input: {
     requestContext: Record<string, unknown>;
     toolCatalog?: OpencodeToolDef[];
     postCompactionRebase?: boolean;
+    hostAgent?: string;
+    systemPromptHash?: string;
 }): Promise<void>;
 export declare function clearPersistedConversationState(cacheDir: string, sessionKey: string, expectedConversationId?: string): Promise<void>;

package/dist/protocol/conversation-state.js

@@ -27,6 +27,8 @@ export async function hydrateConversationState(cacheDir, sessionKey) {
         conversationId: persisted.conversationId,
         postCompactionRebase: persisted.postCompactionRebase,
         toolCatalog: structuredClone(persisted.toolCatalog),
+        ...(persisted.hostAgent ? { hostAgent: persisted.hostAgent } : {}),
+        ...(persisted.systemPromptHash ? { systemPromptHash: persisted.systemPromptHash } : {}),
     };
 }
 /** Persist the complete resumable state only after Cursor confirms TurnEnded. */
@@ -50,6 +52,8 @@ export async function persistConversationState(cacheDir, input) {
         requestContext,
         toolCatalog: structuredClone(input.toolCatalog ?? []),
         postCompactionRebase: input.postCompactionRebase,
+        hostAgent: input.hostAgent,
+        systemPromptHash: input.systemPromptHash,
     });
     trace(`conversation persistence: saved sessionKey=${input.sessionKey} ` +
         `conversationId=${input.conversationId} checkpoint=${checkpoint?.length ?? 0}B ` +

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/switch-mode.d.ts

@@ -8,7 +8,7 @@
  * Display `switch_mode_tool_call` (#25) is a separate transcript record and is
  * not replayed as a host tool.
  *
- * Host mapping (advertisement-gated):
+ * OpenCode 1.x mapping (advertisement-gated):
  * - plan, spec → plan_enter
  * - every other non-empty target → plan_exit (leave plan for OpenCode build),
  *   then inject the Cursor CLI-shaped mode reminder for that target
@@ -19,9 +19,10 @@
  * `setAgentModel` primary-agent switch (opencode `tool/plan.ts`,
  * `session/prompt.ts`). A provider cannot reach `setAgentModel`, but the two
  * observable halves — the approval gate and the behavioural contract — are both
- * reachable, so the bridge degrades instead of refusing when the host tool is
- * missing (`plan_enter` is commented out upstream and `plan_exit` is gated
- * behind OPENCODE_EXPERIMENTAL_PLAN_MODE + CLI client):
+ * reachable, so the protocol bridge degrades instead of refusing when the host
+ * tool is missing. OpenCode 2 additionally exposes `session.switchAgent`; its
+ * entrypoint installs a structural callback that selects the native `plan` or
+ * `build` primary agent after the owning Cursor Run becomes terminal:
  *
  * - entering plan/spec needs no host tool at all — approve immediately and let
  *   the injected <system_reminder> carry the contract, exactly as Cursor CLI's

package/dist/protocol/switch-mode.js

@@ -8,7 +8,7 @@
  * Display `switch_mode_tool_call` (#25) is a separate transcript record and is
  * not replayed as a host tool.
  *
- * Host mapping (advertisement-gated):
+ * OpenCode 1.x mapping (advertisement-gated):
  * - plan, spec → plan_enter
  * - every other non-empty target → plan_exit (leave plan for OpenCode build),
  *   then inject the Cursor CLI-shaped mode reminder for that target
@@ -19,9 +19,10 @@
  * `setAgentModel` primary-agent switch (opencode `tool/plan.ts`,
  * `session/prompt.ts`). A provider cannot reach `setAgentModel`, but the two
  * observable halves — the approval gate and the behavioural contract — are both
- * reachable, so the bridge degrades instead of refusing when the host tool is
- * missing (`plan_enter` is commented out upstream and `plan_exit` is gated
- * behind OPENCODE_EXPERIMENTAL_PLAN_MODE + CLI client):
+ * reachable, so the protocol bridge degrades instead of refusing when the host
+ * tool is missing. OpenCode 2 additionally exposes `session.switchAgent`; its
+ * entrypoint installs a structural callback that selects the native `plan` or
+ * `build` primary agent after the owning Cursor Run becomes terminal:
  *
  * - entering plan/spec needs no host tool at all — approve immediately and let
  *   the injected <system_reminder> carry the contract, exactly as Cursor CLI's
@@ -68,6 +69,7 @@ export const SWITCH_MODE_EXIT_HEADER = "Build Agent";
 const SWITCH_MODE_EXIT_YES = "Yes";
 const SWITCH_MODE_EXIT_NO = "No";
 const activeCursorModeBySession = new Map();
+const MAX_ACTIVE_CURSOR_MODES = 256;
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -248,6 +250,12 @@ export function setActiveCursorMode(sessionKey, targetModeId, options = {}) {
         firstTurn: true,
         bridgedPlanEntered: options.bridgedPlanEntered === true,
     });
+    while (activeCursorModeBySession.size > MAX_ACTIVE_CURSOR_MODES) {
+        const oldest = activeCursorModeBySession.keys().next().value;
+        if (!oldest)
+            break;
+        activeCursorModeBySession.delete(oldest);
+    }
 }
 export function getActiveCursorMode(sessionKey) {
     if (!sessionKey)

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

@@ -1,4 +1,4 @@
-import { mapCursorArgsToOpencode, mapCursorSubagentTypeToOpenCode, mcpRealToolName } from "./tools.js";
+import { mapCursorArgsToOpencode, mapCursorSubagentTypeToOpenCode, mcpRealToolName, } from "./tools.js";
 import { decodeStructEntriesToJson } from "./struct.js";
 import { mapSwitchModeTarget } from "./switch-mode.js";
 const TODO_STATUS = {
@@ -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/protocol/tools.d.ts

@@ -8,6 +8,25 @@ export type OpencodeToolDef = {
     /** Original flattened identity when `name` is a Cursor-facing alias. */
     sourceName?: string;
 };
+/** Host file-tool argument key. OpenCode 1.x uses `filePath`; 2.0 uses `path`. */
+export type HostFilePathKey = "path" | "filePath";
+/** Host shell tool id. OpenCode 1.x uses `bash`; 2.0 uses `shell`. */
+export type HostShellTool = "bash" | "shell";
+export type HostToolDialect = {
+    filePathKey: HostFilePathKey;
+    shellTool: HostShellTool;
+};
+export declare const OPENCODE_1_TOOL_DIALECT: HostToolDialect;
+/** Prefer `filePath`, then `path` / `file_path` — Cursor and both OpenCode majors. */
+export declare function opencodePathArg(args: Record<string, unknown> | undefined): string | undefined;
+/**
+ * Infer the host tool dialect from advertised AI SDK schemas.
+ * OpenCode 2.0 read/edit/write require `path` and rename bash → `shell`.
+ */
+export declare function hostToolDialectFromTools(tools: readonly {
+    name?: string;
+    inputSchema?: unknown;
+}[]): HostToolDialect;
 export declare const CUSTOM_WEBSEARCH_TOOL = "custom_websearch";
 export declare const CUSTOM_WEBFETCH_TOOL = "custom_webfetch";
 export declare const CUSTOM_LIST_MCP_RESOURCES_TOOL = "custom_list_mcp_resources";
@@ -72,9 +91,9 @@ export type HostSubagentDefinition = {
     description?: string;
 };
 export type HostSubagentCatalog = {
-    executor?: "task";
+    executor?: "task" | "subagent";
     agents: HostSubagentDefinition[];
-    /** True when the OpenCode task tool supplied its complete, permission-filtered catalog. */
+    /** True when the OpenCode task/subagent tool supplied its complete, permission-filtered catalog. */
     complete: boolean;
 };
 /** Extract the current host's permission-filtered Task/Actor recipient catalog. */
@@ -143,13 +162,13 @@ export type ParsedExecRequest = {
  * this provider's warning text.
  */
 export declare function rejectPartialReadMutation(parsed: ParsedExecRequest): void;
-export declare function parseExecServerMessage(msg: Record<string, unknown>): ParsedExecRequest | undefined;
+export declare function parseExecServerMessage(msg: Record<string, unknown>, dialect?: HostToolDialect): ParsedExecRequest | undefined;
 /**
  * Remap Cursor exec / MCP arg shapes onto OpenCode's Effect Schema keys.
  * Without this, OpenCode rejects calls with InvalidArgumentsError
  * (e.g. `path` instead of `filePath`, `file_text` instead of `content`).
  */
-export declare function mapCursorArgsToOpencode(toolName: string, raw: Record<string, unknown>, execVariant?: string): {
+export declare function mapCursorArgsToOpencode(toolName: string, raw: Record<string, unknown>, execVariant?: string, dialect?: HostToolDialect): {
     toolName: string;
     args: Record<string, unknown>;
     binaryBytes?: Uint8Array;
@@ -174,6 +193,13 @@ export declare function binaryWritePayload(parsed: ParsedExecRequest): {
     path: string;
     data: Uint8Array;
 } | undefined;
+/**
+ * Replace the prompt-derived task title with Cursor's TaskToolCall description
+ * when the display call is correlated via tool_call_id. SubagentArgs itself has
+ * no description field, so without this OpenCode shows a cut-off first-five-words
+ * slice of the prompt.
+ */
+export declare function preferCorrelatedTaskDescription(parsed: ParsedExecRequest, description: string | undefined): void;
 /**
  * Map Cursor McpArgs back to the OpenCode tool id.
  * Prefers provider_identifier + bare tool_name (github + create_pull_request