cursor-opencode-provider 0.6.8 → 0.7.0

package/dist/protocol/tools.js

@@ -13,6 +13,67 @@ import { BACKGROUND_SHELL_MARKER, buildBackgroundShellCommand, } from "../shell-
 // 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;
+export const OPENCODE_1_TOOL_DIALECT = {
+    filePathKey: "filePath",
+    shellTool: "bash",
+};
+function jsonSchemaProperties(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return undefined;
+    const obj = schema;
+    if (obj.properties && typeof obj.properties === "object" && !Array.isArray(obj.properties)) {
+        return obj.properties;
+    }
+    const nested = obj.jsonSchema;
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+        const props = nested.properties;
+        if (props && typeof props === "object" && !Array.isArray(props)) {
+            return props;
+        }
+    }
+    return undefined;
+}
+/** Prefer `filePath`, then `path` / `file_path` — Cursor and both OpenCode majors. */
+export function opencodePathArg(args) {
+    if (!args)
+        return undefined;
+    return str(args.filePath) ?? str(args.path) ?? str(args.file_path);
+}
+/**
+ * Infer the host tool dialect from advertised AI SDK schemas.
+ * OpenCode 2.0 read/edit/write require `path` and rename bash → `shell`.
+ */
+export function hostToolDialectFromTools(tools) {
+    let filePathKey;
+    for (const name of ["read", "write", "edit"]) {
+        const tool = tools.find((candidate) => candidate.name === name);
+        const props = jsonSchemaProperties(tool?.inputSchema);
+        if (!props)
+            continue;
+        if ("path" in props && !("filePath" in props)) {
+            filePathKey = "path";
+            break;
+        }
+        if ("filePath" in props) {
+            filePathKey = "filePath";
+            break;
+        }
+    }
+    const names = new Set(tools.map((tool) => tool.name).filter((name) => typeof name === "string"));
+    const shellTool = names.has("shell") && !names.has("bash") ? "shell" : "bash";
+    if (!filePathKey) {
+        // OpenCode 2 hosts advertise `shell` and `path` together; use that when schemas are opaque.
+        filePathKey = shellTool === "shell" ? "path" : "filePath";
+    }
+    return { filePathKey, shellTool };
+}
+function assignHostFilePath(args, filePath, dialect) {
+    delete args.filePath;
+    delete args.path;
+    delete args.file_path;
+    if (filePath)
+        args[dialect.filePathKey] = filePath;
+}
 export const CUSTOM_WEBSEARCH_TOOL = "custom_websearch";
 export const CUSTOM_WEBFETCH_TOOL = "custom_webfetch";
 export const CUSTOM_LIST_MCP_RESOURCES_TOOL = "custom_list_mcp_resources";
@@ -171,15 +232,17 @@ export function resolveCustomWebToolAlias(toolName, aliases) {
 export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", knownMcpServers = []) {
     if (tools.length === 0)
         return [];
-    const order = [];
     const byServer = new Map();
-    for (const t of tools) {
+    // OpenCode's tool catalog is a set even though the hook exposes it as an
+    // array. Keep both the server and per-server tool order canonical so a host
+    // that enumerates the same catalog differently does not invalidate Cursor's
+    // RequestContext prefix cache.
+    for (const t of [...tools].sort((left, right) => left.name.localeCompare(right.name))) {
         const id = resolveToolServerIdentity(t.sourceName ?? 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: t.sourceName ? t.name : id.toolName,
@@ -187,7 +250,14 @@ export function toolsToMcpDescriptors(tools, providerIdentifier = "opencode", kn
             input_schema: encodeJsonAsValue(normalizeInputSchema(t.inputSchema)),
         });
     }
-    return order.map((server) => ({
+    const orderedServers = [...byServer.keys()].sort((left, right) => {
+        if (left === providerIdentifier)
+            return right === providerIdentifier ? 0 : -1;
+        if (right === providerIdentifier)
+            return 1;
+        return left.localeCompare(right);
+    });
+    return orderedServers.map((server) => ({
         server_name: server,
         server_identifier: server,
         tools: byServer.get(server),
@@ -262,6 +332,7 @@ const opencodeToolToCursor = {
     write: "write_args",
     grep: "grep_args",
     bash: "shell_stream_args",
+    shell: "shell_stream_args",
     task: "subagent_args",
     mcp: "mcp_args",
 };
@@ -348,33 +419,54 @@ const CURSOR_SUBAGENT_TYPE_TO_OPENCODE = {
     security_review: "explore",
 };
 const SUBAGENT_CATALOG_MARKER = "Available agent types and the tools they have access to:";
+const SUBAGENT_INLINE_MARKER = "Available subagents:";
 function parseSubagentDescriptionCatalog(description) {
     if (!description)
         return { found: false, agents: [] };
     const marker = description.indexOf(SUBAGENT_CATALOG_MARKER);
-    if (marker < 0)
+    if (marker >= 0) {
+        const agents = [];
+        const lines = description.slice(marker + SUBAGENT_CATALOG_MARKER.length).split(/\r?\n/);
+        let started = false;
+        for (const line of lines) {
+            const match = line.match(/^\s*-\s+([^:]+):\s*(.*)$/);
+            if (!match) {
+                if (started && line.trim())
+                    break;
+                continue;
+            }
+            started = true;
+            const name = match[1].trim().replace(/^`|`$/g, "");
+            if (!name)
+                continue;
+            const agentDescription = match[2].trim();
+            agents.push({
+                name,
+                ...(agentDescription ? { description: agentDescription } : {}),
+            });
+        }
+        return { found: true, agents };
+    }
+    // OpenCode 2 `subagent` inlines the list after "Available subagents:".
+    const inlineAt = description.indexOf(SUBAGENT_INLINE_MARKER);
+    if (inlineAt < 0)
         return { found: false, agents: [] };
+    const rest = description.slice(inlineAt + SUBAGENT_INLINE_MARKER.length);
     const agents = [];
-    const lines = description.slice(marker + SUBAGENT_CATALOG_MARKER.length).split(/\r?\n/);
-    let started = false;
-    for (const line of lines) {
-        const match = line.match(/^\s*-\s+([^:]+):\s*(.*)$/);
-        if (!match) {
-            if (started && line.trim())
-                break;
-            continue;
-        }
-        started = true;
-        const name = match[1].trim().replace(/^`|`$/g, "");
-        if (!name)
-            continue;
-        const agentDescription = match[2].trim();
+    const matches = rest.matchAll(/-\s+([A-Za-z0-9_-]+):\s*/g);
+    const hits = [...matches];
+    for (let i = 0; i < hits.length; i++) {
+        const hit = hits[i];
+        const name = hit[1];
+        const start = (hit.index ?? 0) + hit[0].length;
+        const end = i + 1 < hits.length ? (hits[i + 1].index ?? rest.length) : rest.length;
+        const agentDescription = rest.slice(start, end).trim();
         agents.push({
             name,
             ...(agentDescription ? { description: agentDescription } : {}),
         });
     }
-    return { found: true, agents };
+    return { found: agents.length > 0, agents };
 }
 function subagentTypeEnumValues(schema) {
     const out = new Set();
@@ -391,7 +483,8 @@ function subagentTypeEnumValues(schema) {
             return;
         }
         const record = value;
-        if (propertyName === "subagent_type" && Array.isArray(record.enum)) {
+        if ((propertyName === "subagent_type" || propertyName === "agent")
+            && Array.isArray(record.enum)) {
             for (const item of record.enum) {
                 if (typeof item === "string" && item)
                     out.add(item);
@@ -405,16 +498,17 @@ function subagentTypeEnumValues(schema) {
 }
 /** Extract the current host's permission-filtered Task/Actor recipient catalog. */
 export function extractHostSubagentCatalog(tools) {
-    const executorTool = tools.find((tool) => tool.name === "task");
+    const executorTool = tools.find((tool) => tool.name === "task")
+        ?? tools.find((tool) => tool.name === "subagent");
     if (!executorTool)
         return { agents: [], complete: true };
     const described = parseSubagentDescriptionCatalog(executorTool.description);
     const enumNames = subagentTypeEnumValues(executorTool.inputSchema);
     const descriptions = new Map(described.agents.map((agent) => [agent.name, agent.description]));
-    // A structured subagent_type enum is stricter than prose, so it is authoritative.
+    // A structured subagent_type/agent enum is stricter than prose, so it is authoritative.
     const names = new Set(enumNames.length > 0 ? enumNames : described.agents.map((agent) => agent.name));
     return {
-        executor: "task",
+        executor: executorTool.name === "subagent" ? "subagent" : "task",
         agents: [...names].map((name) => ({
             name,
             ...(descriptions.get(name) ? { description: descriptions.get(name) } : {}),
@@ -474,13 +568,19 @@ export function remapNativeSubagentForCatalog(parsed, advertisedToolNames, catal
     if (parsed.resultField !== "subagent_result" || parsed.toolName !== "task")
         return;
     const advertised = new Set(advertisedToolNames);
-    if (!advertised.has("task"))
+    const executor = advertised.has("task")
+        ? "task"
+        : advertised.has("subagent")
+            ? "subagent"
+            : undefined;
+    if (!executor)
         return;
-    const executor = "task";
     const description = str(parsed.args.description) ?? "";
     const prompt = str(parsed.args.prompt) ?? "";
     const cursorSubagentType = str(parsed.resultMetadata?.cursor_subagent_type) ??
-        str(parsed.args.subagent_type) ?? "";
+        str(parsed.args.subagent_type) ??
+        str(parsed.args.agent) ??
+        "";
     const subagentType = resolveCursorSubagentType(cursorSubagentType, catalog);
     if (!subagentType) {
         const available = catalog?.agents.map((agent) => agent.name).join(", ") || "none";
@@ -489,15 +589,23 @@ export function remapNativeSubagentForCatalog(parsed, advertisedToolNames, catal
                 `Available subagents: ${available}.`;
         return;
     }
-    const resumeAgentId = str(parsed.args.task_id);
+    const resumeAgentId = str(parsed.args.task_id) ?? str(parsed.args.sessionID);
     parsed.toolName = executor;
-    parsed.args = {
-        description,
-        prompt,
-        subagent_type: subagentType,
-        ...(resumeAgentId ? { task_id: resumeAgentId } : {}),
-        ...(parsed.args.background === true ? { background: true } : {}),
-    };
+    parsed.args = executor === "subagent"
+        ? {
+            agent: subagentType,
+            description,
+            prompt,
+            ...(resumeAgentId ? { sessionID: resumeAgentId } : {}),
+            ...(parsed.args.background === true ? { background: true } : {}),
+        }
+        : {
+            description,
+            prompt,
+            subagent_type: subagentType,
+            ...(resumeAgentId ? { task_id: resumeAgentId } : {}),
+            ...(parsed.args.background === true ? { background: true } : {}),
+        };
 }
 /** Matches Cursor's own pre-write read threshold (`local-exec` 52428800). */
 const MAX_EDIT_SOURCE_BYTES = 50 * 1024 * 1024;
@@ -625,7 +733,7 @@ export function remapCorrelatedEditWriteForCatalog(parsed, advertisedToolNames,
     const advertised = new Set(advertisedToolNames);
     if (!advertised.has("edit") && !advertised.has(APPLY_PATCH_TOOL))
         return false;
-    const filePath = str(parsed.args.filePath);
+    const filePath = opencodePathArg(parsed.args);
     const content = stringValue(parsed.args.content);
     if (!filePath || content === undefined || !editPath)
         return false;
@@ -651,8 +759,11 @@ export function remapCorrelatedEditWriteForCatalog(parsed, advertisedToolNames,
     if (!replacement)
         return false;
     parsed.toolName = "edit";
+    const filePathKey = typeof parsed.args.path === "string" && typeof parsed.args.filePath !== "string"
+        ? "path"
+        : "filePath";
     parsed.args = {
-        filePath,
+        [filePathKey]: filePath,
         oldString: replacement.oldString,
         newString: replacement.newString,
     };
@@ -687,7 +798,7 @@ export function remapEditToolsForCatalog(parsed, advertisedToolNames, workspaceR
     if (advertised.has(parsed.toolName) || !advertised.has(APPLY_PATCH_TOOL))
         return;
     const requested = parsed.toolName;
-    const filePath = str(parsed.args.filePath);
+    const filePath = opencodePathArg(parsed.args);
     const refuse = (reason) => {
         parsed.toolName = APPLY_PATCH_TOOL;
         parsed.args = {};
@@ -775,9 +886,7 @@ export function rejectPartialReadMutation(parsed) {
         || !content.includes("[Partial read:")
         || !content.includes("It is NOT the complete file."))
         return;
-    const filePath = typeof parsed.args.filePath === "string"
-        ? parsed.args.filePath
-        : "the target file";
+    const filePath = opencodePathArg(parsed.args) ?? "the target file";
     const nextOffset = /Continue with offset=(\d+)/.exec(content)?.[1];
     parsed.localError =
         `NO FILE CHANGE WAS MADE. Refusing a whole-file mutation of ${JSON.stringify(filePath)} ` +
@@ -786,7 +895,7 @@ export function rejectPartialReadMutation(parsed) {
                 ? `Read the file from offset=${nextOffset}, then use a targeted edit or Update File patch.`
                 : "Read the remaining file ranges, then use a targeted edit or Update File patch.");
 }
-export function parseExecServerMessage(msg) {
+export function parseExecServerMessage(msg, dialect = OPENCODE_1_TOOL_DIALECT) {
     const id = msg.id;
     if (id === undefined)
         return undefined;
@@ -823,7 +932,7 @@ export function parseExecServerMessage(msg) {
         return {
             id,
             execId,
-            toolName: "bash",
+            toolName: dialect.shellTool,
             args,
             resultField,
             resultMetadata: {
@@ -877,7 +986,7 @@ export function parseExecServerMessage(msg) {
         // tool name (Cursor's model may have shortened "opencode-read" → "read") and
         // decode the argument map back into JSON for opencode to execute.
         const m = msg.mcp_args ?? {};
-        const mapped = mapCursorArgsToOpencode(mcpRealToolName(m), decodeMcpArgs(m.args), "mcp_args");
+        const mapped = mapCursorArgsToOpencode(mcpRealToolName(m), decodeMcpArgs(m.args), "mcp_args", dialect);
         return {
             id,
             execId,
@@ -896,8 +1005,7 @@ export function parseExecServerMessage(msg) {
         const oldString = replacement ? stringValue(replacement.old_text) : undefined;
         const newString = replacement ? stringValue(replacement.new_text) : undefined;
         const args = {};
-        if (path)
-            args.filePath = path;
+        assignHostFilePath(args, path, dialect);
         if (oldString !== undefined)
             args.oldString = oldString;
         if (newString !== undefined)
@@ -916,7 +1024,7 @@ export function parseExecServerMessage(msg) {
     const toolName = cursorToolToOpencode[execVariant];
     if (!toolName)
         return undefined;
-    const mapped = mapCursorArgsToOpencode(toolName, msg[execVariant] ?? {}, execVariant);
+    const mapped = mapCursorArgsToOpencode(toolName, msg[execVariant] ?? {}, execVariant, dialect);
     const rawArgs = msg[execVariant] ?? {};
     const resultMetadata = execVariant === "shell_stream_args" || execVariant === "shell_args"
         ? shellStreamResultMetadata(rawArgs)
@@ -980,7 +1088,7 @@ function shellStreamResultMetadata(raw) {
  * Without this, OpenCode rejects calls with InvalidArgumentsError
  * (e.g. `path` instead of `filePath`, `file_text` instead of `content`).
  */
-export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
+export function mapCursorArgsToOpencode(toolName, raw, execVariant, dialect = OPENCODE_1_TOOL_DIALECT) {
     const cleaned = {};
     for (const [k, v] of Object.entries(raw)) {
         if (v === undefined || v === null)
@@ -996,7 +1104,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
     // Native ls_args → OpenCode read (directory listing via read).
     if (execVariant === "ls_args") {
         const filePath = str(cleaned.path) ?? str(cleaned.filePath);
-        return { toolName: "read", args: filePath ? { filePath } : {} };
+        return { toolName: "read", args: filePath ? { [dialect.filePathKey]: filePath } : {} };
     }
     // F11: Cursor native delete_args → OpenCode bash. No delete builtin exists, so
     // we emulate with `rm -f -- <path>` (shell-quoted). Same permission boundary
@@ -1004,7 +1112,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
     if (execVariant === "delete_args") {
         const target = str(cleaned.path) ?? str(cleaned.filePath);
         return {
-            toolName: "bash",
+            toolName: dialect.shellTool,
             args: target ? { command: `rm -f -- ${shellQuote(target)}` } : { command: "true" },
         };
     }
@@ -1012,8 +1120,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
         case "read": {
             const args = {};
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
-            if (filePath)
-                args.filePath = filePath;
+            assignHostFilePath(args, filePath, dialect);
             // Cursor often sends offset=0/limit=0 as protobuf defaults. OpenCode's
             // read treats limit=0 as "read zero lines" (empty content) — omit zeros.
             const offset = num(cleaned.offset);
@@ -1027,8 +1134,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
         case "write": {
             const args = {};
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
-            if (filePath)
-                args.filePath = filePath;
+            assignHostFilePath(args, filePath, dialect);
             // Cursor's LocalWriteExecutor prefers `file_bytes` whenever it is
             // non-empty and only falls back to `file_text`; mirror that order so a
             // byte-encoded write is not silently seen as empty content.
@@ -1060,8 +1166,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
             }
             const args = {};
             const filePath = str(cleaned.filePath) ?? str(cleaned.path) ?? str(cleaned.file_path);
-            if (filePath)
-                args.filePath = filePath;
+            assignHostFilePath(args, filePath, dialect);
             const oldString = stringValue(cleaned.oldString) ?? stringValue(cleaned.old_string);
             if (oldString !== undefined)
                 args.oldString = oldString;
@@ -1072,7 +1177,8 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
                 args.replaceAll = cleaned.replaceAll;
             return { toolName: "edit", args };
         }
-        case "bash": {
+        case "bash":
+        case "shell": {
             const args = {};
             const command = str(cleaned.command);
             if (command)
@@ -1083,7 +1189,7 @@ export function mapCursorArgsToOpencode(toolName, raw, execVariant) {
             const timeout = num(cleaned.timeout);
             if (timeout !== undefined)
                 args.timeout = timeout;
-            return { toolName: "bash", args };
+            return { toolName: dialect.shellTool, args };
         }
         case "grep": {
             const pattern = str(cleaned.pattern);
@@ -1193,12 +1299,33 @@ function num(v) {
         return Number(v);
     return undefined;
 }
+/**
+ * Fallback OpenCode task title when Cursor's SubagentArgs has no description.
+ * Prefer {@link preferCorrelatedTaskDescription} when a TaskToolCall is available —
+ * that carries Cursor's real 3–5 word title. This only slices the prompt.
+ */
 function describeSubagentTask(prompt, subagentType) {
     const words = prompt?.replace(/\s+/g, " ").trim().split(" ").filter(Boolean).slice(0, 5);
     if (words?.length)
         return words.join(" ");
     return `${subagentType || "Delegated"} task`;
 }
+/**
+ * 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 function preferCorrelatedTaskDescription(parsed, description) {
+    if (parsed.toolName !== "task" && parsed.toolName !== "subagent")
+        return;
+    if (parsed.resultField !== "subagent_result")
+        return;
+    const trimmed = description?.trim();
+    if (!trimmed)
+        return;
+    parsed.args.description = trimmed;
+}
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }

package/dist/session.d.ts

@@ -1,7 +1,7 @@
 import type { BidiStream } from "./transport/connect.js";
 import { type CursorProviderError } from "./errors.js";
 import { type SessionActivitySource } from "./activity.js";
-import type { HostSubagentCatalog, OpencodeToolDef, ToolAliasRegistry } from "./protocol/tools.js";
+import type { HostSubagentCatalog, HostToolDialect, OpencodeToolDef, ToolAliasRegistry } from "./protocol/tools.js";
 import type { CursorConversationTokenDetails } from "./protocol/token-details.js";
 export type Frame = {
     flags: number;
@@ -134,6 +134,10 @@ export type CursorSession = {
     };
     /** OpenCode session whose own or descendant activity renews tool leases. */
     openCodeSessionId?: string;
+    /** Host primary agent whose prompt/permissions this Run was seeded with. */
+    hostAgent?: string;
+    /** Stable host-system + provider-guidance identity for restart validation. */
+    stableSystemPromptHash?: string;
     /** Completed compaction must rebase once before resuming a normal agent. */
     postCompactionRebase?: boolean;
     /** Last real host catalog, retained only as a lifecycle-turn fallback. */
@@ -170,6 +174,8 @@ export type CursorSession = {
     toolDescriptors: Array<Record<string, unknown>>;
     /** Cursor-facing web alias → exact executable host tool for this Run. */
     toolAliases?: ToolAliasRegistry;
+    /** OpenCode 1.x `filePath`/`bash` vs 2.x `path`/`shell`, from advertised schemas. */
+    hostToolDialect?: HostToolDialect;
     /** Spawnable host agents extracted from this turn's Task/Actor definition. */
     subagentCatalog?: HostSubagentCatalog;
     /** Full RequestContext for exec #10 replies. */

package/dist/shared.d.ts

@@ -4,6 +4,8 @@ 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";
+/** Current OpenCode primary agent; used to invalidate incompatible checkpoints. */
+export declare const CURSOR_HOST_AGENT_OPTION = "opencodeHostAgent";
 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";
@@ -13,7 +15,7 @@ export declare const MODEL_CACHE_FILE = "cursor-models.json";
 export declare const MODEL_CACHE_SCHEMA_VERSION = 3;
 export declare const MODEL_CACHE_TTL_MS = 86400000;
 export declare const CONVERSATION_CACHE_DIR = "cursor-conversations";
-export declare const CONVERSATION_CACHE_SCHEMA_VERSION = 3;
+export declare const CONVERSATION_CACHE_SCHEMA_VERSION = 4;
 export declare const CONVERSATION_CACHE_TTL_MS = 86400000;
 export declare const VERSION_CACHE_FILE = "cursor-client-version.json";
 export declare const CONTENT_TYPE_CONNECT_PROTO = "application/connect+proto";

package/dist/shared.js

@@ -4,6 +4,8 @@ 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";
+/** Current OpenCode primary agent; used to invalidate incompatible checkpoints. */
+export const CURSOR_HOST_AGENT_OPTION = "opencodeHostAgent";
 export const TOKEN_EXPIRY_THRESHOLD_S = 300;
 export const RUN_PATH = "/agent.v1.AgentService/Run";
 export const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
@@ -13,7 +15,7 @@ export const MODEL_CACHE_FILE = "cursor-models.json";
 export const MODEL_CACHE_SCHEMA_VERSION = 3;
 export const MODEL_CACHE_TTL_MS = 86_400_000;
 export const CONVERSATION_CACHE_DIR = "cursor-conversations";
-export const CONVERSATION_CACHE_SCHEMA_VERSION = 3;
+export const CONVERSATION_CACHE_SCHEMA_VERSION = 4;
 export const CONVERSATION_CACHE_TTL_MS = 86_400_000;
 export const VERSION_CACHE_FILE = "cursor-client-version.json";
 export const CONTENT_TYPE_CONNECT_PROTO = "application/connect+proto";

package/dist/shell-timeout.d.ts

@@ -85,9 +85,19 @@ export declare function releaseCursorShellEnv(toolCallId: string): void;
  * same materialized wrapper backs the direct-command sh/dash fallback.
  */
 export declare function cursorShellEnvForCall(toolCallId: string | undefined): Record<string, string> | undefined;
+/**
+ * OpenCode 2.0 `shell.create.before` has no tool-call id. Correlate the pending
+ * wrap by command + working directory when possible, then fall back to the
+ * original command for hosts that omit the directory.
+ */
+export declare function cursorShellEnvForCommand(command: string | undefined, workingDirectory?: string): Record<string, string> | undefined;
 /**
  * Strip private wrapper sentinels / OpenCode timeout envelopes for display.
  * Does not record outcomes — use {@link captureCursorShellResult} for that.
+ *
+ * OpenCode 2.0 `Tool.Result.output` is structured (an object for shell), not
+ * a string. Non-string input is returned unchanged so the 2.0 after-hook can
+ * pass structured output through safely.
  */
 export declare function sanitizeCursorShellDisplayOutput(output: string, policy?: CursorShellPolicy): string;
 /** Sanitize a secondary display string (e.g. Bash `metadata.output`) for a registered call. */
@@ -95,6 +105,9 @@ export declare function sanitizeRegisteredCursorShellOutput(toolCallId: string,
 /**
  * Capture Bash completion in the classic plugin's after hook. Returns the
  * sanitized output that OpenCode should store and render.
+ *
+ * Guards non-string output (OpenCode 2.0 structured `Tool.Result.output`)
+ * by returning it unchanged.
  */
 export declare function captureCursorShellResult(toolCallId: string, output: string, metadata?: Record<string, unknown>): string;
 /** Consume the structured result, with an inline fallback when no plugin hook ran. */

package/dist/shell-timeout.js

@@ -269,6 +269,31 @@ export function cursorShellEnvForCall(toolCallId) {
     pendingEnvWraps.delete(toolCallId);
     return wrap.env;
 }
+/**
+ * OpenCode 2.0 `shell.create.before` has no tool-call id. Correlate the pending
+ * wrap by command + working directory when possible, then fall back to the
+ * original command for hosts that omit the directory.
+ */
+export function cursorShellEnvForCommand(command, workingDirectory) {
+    if (typeof command !== "string" || !command)
+        return undefined;
+    if (workingDirectory) {
+        for (const [id, policy] of policies) {
+            if (!pendingEnvWraps.has(id))
+                continue;
+            if (policy.command === command && policy.workingDirectory === workingDirectory) {
+                return cursorShellEnvForCall(id);
+            }
+        }
+    }
+    for (const [id, policy] of policies) {
+        if (!pendingEnvWraps.has(id))
+            continue;
+        if (policy.command === command)
+            return cursorShellEnvForCall(id);
+    }
+    return undefined;
+}
 function withoutMarker(output, index) {
     let clean = output.slice(0, index).replace(/[\t ]+$/gm, "").replace(/\n{2,}$/, "\n");
     if (clean.trim() === "" || clean.trim() === "(no output)")
@@ -390,8 +415,14 @@ function parseBackgroundSpawnOutcome(output, policy) {
 /**
  * Strip private wrapper sentinels / OpenCode timeout envelopes for display.
  * Does not record outcomes — use {@link captureCursorShellResult} for that.
+ *
+ * OpenCode 2.0 `Tool.Result.output` is structured (an object for shell), not
+ * a string. Non-string input is returned unchanged so the 2.0 after-hook can
+ * pass structured output through safely.
  */
 export function sanitizeCursorShellDisplayOutput(output, policy) {
+    if (typeof output !== "string")
+        return output;
     if (policy?.backgroundSpawn) {
         const spawn = parseBackgroundSpawnOutcome(output, policy);
         if (spawn)
@@ -413,6 +444,8 @@ export function sanitizeCursorShellDisplayOutput(output, policy) {
 }
 /** Sanitize a secondary display string (e.g. Bash `metadata.output`) for a registered call. */
 export function sanitizeRegisteredCursorShellOutput(toolCallId, output) {
+    if (typeof output !== "string")
+        return output;
     if (typeof toolCallId !== "string" || !toolCallId)
         return output;
     return sanitizeCursorShellDisplayOutput(output, policies.get(toolCallId));
@@ -420,8 +453,13 @@ export function sanitizeRegisteredCursorShellOutput(toolCallId, output) {
 /**
  * Capture Bash completion in the classic plugin's after hook. Returns the
  * sanitized output that OpenCode should store and render.
+ *
+ * Guards non-string output (OpenCode 2.0 structured `Tool.Result.output`)
+ * by returning it unchanged.
  */
 export function captureCursorShellResult(toolCallId, output, metadata) {
+    if (typeof output !== "string")
+        return output;
     if (typeof toolCallId !== "string" || !toolCallId.startsWith("cursor_"))
         return output;
     const policy = policies.get(toolCallId);

package/dist/todo-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Per-session todo list used when the host does not ship `todowrite` /
+ * `todoread` (OpenCode 2 dropped those builtins; OpenCode 1.x still has
+ * `todowrite`).
+ *
+ * In-memory only — same lifetime as the provider process. A restart clears
+ * the list until the next write/read, matching the mirrored Cursor-todo
+ * snapshot in `language-model.ts`.
+ */
+export declare const TODOWRITE_TOOL = "todowrite";
+export declare const TODOREAD_TOOL = "todoread";
+export declare const TODO_STATUSES: readonly ["pending", "in_progress", "completed", "cancelled"];
+export type TodoStatus = (typeof TODO_STATUSES)[number];
+export declare const TODO_PRIORITIES: readonly ["high", "medium", "low"];
+export type TodoPriority = (typeof TODO_PRIORITIES)[number];
+export type SessionTodo = {
+    id: string;
+    content: string;
+    status: TodoStatus;
+    priority: TodoPriority;
+};
+/** Normalize one host/Cursor todo item. Drops entries with empty content. */
+export declare function normalizeSessionTodo(value: unknown, index: number): SessionTodo | undefined;
+export declare function normalizeSessionTodos(value: unknown): SessionTodo[];
+export declare function getSessionTodos(sessionID: string): SessionTodo[];
+export declare function setSessionTodos(sessionID: string, todos: unknown): SessionTodo[];
+export declare function clearSessionTodos(sessionID: string): void;
+/** Test-only: drop every session list. */
+export declare function clearAllSessionTodos(): void;