cursor-opencode-provider 0.6.8 → 0.7.1

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

@@ -1 +1,17 @@
-export declare function appendWorkspaceRootGrounding(reason: string, workspaceRoot: string | undefined): string;
+export type WorkspaceGroundingOptions = {
+    /** OpenCode 2 file tools take `path` and do not say it must be absolute. */
+    requireAbsolutePathArg?: boolean;
+};
+/**
+ * Attach the exact workspace root to a model-visible string.
+ *
+ * Idempotent: a second call does not stack another root line. The absolute-path
+ * sentence is added only when requested, and only once.
+ */
+export declare function appendWorkspaceRootGrounding(reason: string, workspaceRoot: string | undefined, options?: WorkspaceGroundingOptions): string;
+/**
+ * Checkpointed Runs omit the system prompt, which is where the root normally
+ * lives. Put the same reminder on the live user message so a later turn cannot
+ * invent an absolute prefix before any tool result arrives.
+ */
+export declare function appendCheckpointUserGrounding(userText: string, workspaceRoot: string | undefined, options?: WorkspaceGroundingOptions): string;

package/dist/protocol/workspace-grounding.js

@@ -1,8 +1,37 @@
-export function appendWorkspaceRootGrounding(reason, workspaceRoot) {
+const ABSOLUTE_PATH_ARG = "OpenCode file tools take `path` as an absolute path under this root. Do not pass a project-relative path, and do not invent a different absolute prefix.";
+/**
+ * Attach the exact workspace root to a model-visible string.
+ *
+ * Idempotent: a second call does not stack another root line. The absolute-path
+ * sentence is added only when requested, and only once.
+ */
+export function appendWorkspaceRootGrounding(reason, workspaceRoot, options) {
     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.");
+    const pathSentence = options?.requireAbsolutePathArg ? ` ${ABSOLUTE_PATH_ARG}` : "";
+    if (reason.includes("Workspace root:")) {
+        if (!pathSentence || reason.includes("take `path` as an absolute path"))
+            return reason;
+        return `${reason}${pathSentence}`;
+    }
+    const note = `Workspace root: ${JSON.stringify(workspaceRoot)}. ` +
+        "Resolve workspace paths against exactly this root; never invent an absolute prefix, and verify uncertain paths with an available tool before using them." +
+        pathSentence;
+    if (!reason)
+        return note;
+    return `${reason}\n${note}`;
+}
+/**
+ * Checkpointed Runs omit the system prompt, which is where the root normally
+ * lives. Put the same reminder on the live user message so a later turn cannot
+ * invent an absolute prefix before any tool result arrives.
+ */
+export function appendCheckpointUserGrounding(userText, workspaceRoot, options) {
+    const note = appendWorkspaceRootGrounding("", workspaceRoot, options);
+    if (!note)
+        return userText;
+    if (userText.includes("Workspace root:")) {
+        return appendWorkspaceRootGrounding(userText, workspaceRoot, options);
+    }
+    return userText ? `${userText}\n\n${note}` : note;
 }

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;

package/dist/todo-store.js

@@ -0,0 +1,78 @@
+/**
+ * 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 const TODOWRITE_TOOL = "todowrite";
+export const TODOREAD_TOOL = "todoread";
+export const TODO_STATUSES = ["pending", "in_progress", "completed", "cancelled"];
+export const TODO_PRIORITIES = ["high", "medium", "low"];
+const lists = new Map();
+const MAX_TRACKED_SESSIONS = 256;
+function isStatus(value) {
+    return typeof value === "string" && TODO_STATUSES.includes(value);
+}
+function isPriority(value) {
+    return typeof value === "string" && TODO_PRIORITIES.includes(value);
+}
+/** Normalize one host/Cursor todo item. Drops entries with empty content. */
+export function normalizeSessionTodo(value, index) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const content = typeof record.content === "string" ? record.content : "";
+    if (!content.trim())
+        return undefined;
+    const id = typeof record.id === "string" && record.id.trim()
+        ? record.id.trim()
+        : String(index + 1);
+    return {
+        id,
+        content,
+        status: isStatus(record.status) ? record.status : "pending",
+        priority: isPriority(record.priority) ? record.priority : "medium",
+    };
+}
+export function normalizeSessionTodos(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of value) {
+        const todo = normalizeSessionTodo(item, out.length);
+        if (!todo)
+            continue;
+        let id = todo.id;
+        if (seen.has(id))
+            id = `${id}-${out.length + 1}`;
+        seen.add(id);
+        out.push(id === todo.id ? todo : { ...todo, id });
+    }
+    return out;
+}
+export function getSessionTodos(sessionID) {
+    return lists.get(sessionID)?.map((todo) => ({ ...todo })) ?? [];
+}
+export function setSessionTodos(sessionID, todos) {
+    const normalized = normalizeSessionTodos(todos);
+    lists.delete(sessionID);
+    lists.set(sessionID, normalized.map((todo) => ({ ...todo })));
+    while (lists.size > MAX_TRACKED_SESSIONS) {
+        const oldest = lists.keys().next().value;
+        if (oldest === undefined)
+            break;
+        lists.delete(oldest);
+    }
+    return getSessionTodos(sessionID);
+}
+export function clearSessionTodos(sessionID) {
+    lists.delete(sessionID);
+}
+/** Test-only: drop every session list. */
+export function clearAllSessionTodos() {
+    lists.clear();
+}

package/dist/web-tools.d.ts

@@ -14,5 +14,18 @@ export declare function parseOpenCodeWebSearchResponse(raw: string): string | un
  * OpenCode 2.0 plugin's tool registration share one implementation — 2.0's
  * ToolContext has no `ask`, permissions being handled by the host instead.
  */
+export type OpenCode2WebSearchResult = {
+    url: string;
+    title?: string;
+    content?: string;
+    time: {
+        published?: number;
+    };
+};
+/**
+ * Turn an Exa MCP text blob into OpenCode 2.0 `websearch` results
+ * (`{ url, title?, content?, time }`). Unknown shapes yield an empty list.
+ */
+export declare function parseExaWebSearchResults(raw: string): OpenCode2WebSearchResult[];
 export declare function fetchOpenCodeWebSearchText(args: OpenCodeWebSearchArgs, signal: AbortSignal | undefined, fetchImpl?: typeof fetch): Promise<string>;
 export declare function executeOpenCodeWebSearch(args: OpenCodeWebSearchArgs, context: ToolContext, fetchImpl?: typeof fetch): Promise<ToolResult>;

package/dist/web-tools.js

@@ -53,13 +53,91 @@ export function parseOpenCodeWebSearchResponse(raw) {
     }
     return undefined;
 }
+function tryParseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function publishedMs(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 1e12 ? Math.floor(value * 1000) : Math.floor(value);
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function asWebSearchResult(row) {
+    if (!row || typeof row !== "object")
+        return undefined;
+    const record = row;
+    const url = typeof record.url === "string" ? record.url
+        : typeof record.href === "string" ? record.href
+            : undefined;
+    if (!url)
+        return undefined;
+    const title = typeof record.title === "string" ? record.title : undefined;
+    const content = typeof record.content === "string" ? record.content
+        : typeof record.text === "string" ? record.text
+            : typeof record.snippet === "string" ? record.snippet
+                : undefined;
+    const published = publishedMs(record.publishedDate ?? record.published ?? record.date);
+    return {
+        url,
+        ...(title ? { title } : {}),
+        ...(content ? { content } : {}),
+        time: published !== undefined ? { published } : {},
+    };
+}
+function parseExaTextResults(text) {
+    return text.split(/\n\n---\n\n/).flatMap((block) => {
+        const url = block.match(/^URL:\s*(.+)$/m)?.[1]?.trim();
+        if (!url)
+            return [];
+        const title = block.match(/^Title:\s*(.+)$/m)?.[1]?.trim();
+        const publishedText = block.match(/^Published:\s*(.+)$/m)?.[1]?.trim();
+        const published = publishedText && publishedText !== "N/A"
+            ? publishedMs(publishedText)
+            : undefined;
+        const content = block.match(/^(?:Highlights|Text):\s*\n?([\s\S]*)$/m)?.[1]?.trim();
+        return [{
+                url,
+                ...(title && title !== "N/A" ? { title } : {}),
+                ...(content ? { content } : {}),
+                time: published === undefined ? {} : { published },
+            }];
+    });
+}
 /**
- * Raw Exa web-search call: no host tool context, no permission prompt.
- *
- * Split out so both the classic plugin's `custom_websearch` tool and the
- * OpenCode 2.0 plugin's tool registration share one implementation — 2.0's
- * ToolContext has no `ask`, permissions being handled by the host instead.
+ * Turn an Exa MCP text blob into OpenCode 2.0 `websearch` results
+ * (`{ url, title?, content?, time }`). Unknown shapes yield an empty list.
  */
+export function parseExaWebSearchResults(raw) {
+    const text = parseOpenCodeWebSearchResponse(raw) ?? raw.trim();
+    if (!text)
+        return [];
+    const parsed = tryParseJson(text);
+    const rows = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === "object"
+            ? Array.isArray(parsed.results)
+                ? parsed.results
+                : Array.isArray(parsed.data)
+                    ? parsed.data
+                    : []
+            : [];
+    if (rows.length > 0) {
+        return rows.flatMap((row) => {
+            const result = asWebSearchResult(row);
+            return result ? [result] : [];
+        });
+    }
+    return parseExaTextResults(text);
+}
 export async function fetchOpenCodeWebSearchText(args, signal, fetchImpl = fetch) {
     const controller = new AbortController();
     const abort = () => controller.abort(signal?.reason);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.6.8",
+  "version": "0.7.1",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -40,6 +40,10 @@
       "types": "./dist/plugin-opencode2.d.ts",
       "import": "./dist/plugin-opencode2.js"
     },
+    "./server": {
+      "types": "./dist/plugin-opencode2.d.ts",
+      "import": "./dist/plugin-opencode2.js"
+    },
     "./errors": {
       "types": "./dist/errors.d.ts",
       "import": "./dist/errors.js"
@@ -70,7 +74,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
     "test": "bun test",
     "test:node-http2": "bun run build && node test/node-http2-cleanup.mjs",
     "test:watch": "bun test --watch",
@@ -93,7 +97,6 @@
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.18.16",
-    "@opencode-ai/plugin-next": "npm:@opencode-ai/plugin@0.0.0-next-17155",
     "@tsconfig/node22": "^22.0.5",
     "@types/bun": "^1.3.0",
     "@types/node": "^22.20.1",