cursor-opencode-provider 0.7.5 → 0.8.0

package/dist/protocol/turn-provenance.d.ts

@@ -0,0 +1,52 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+/** Mirrors MAX_TURN_STATE_SESSIONS; evicted sessions re-hydrate from disk. */
+export declare const MAX_PROVENANCE_SESSIONS = 256;
+export type TurnProvenance = {
+    conversationId: string;
+    /** Tool call ids emitted in the latest non-empty step. */
+    toolCallIds: string[];
+    /** Whitespace-free text emitted in the latest non-empty step (first 4 KiB). */
+    text: string;
+    /**
+     * Whitespace-free reasoning and text of the same step in emission order
+     * (first 4 KiB). OpenCode 1.x replays a previous model's reasoning as text
+     * parts after a model switch (`session/message-v2.ts` `differentModel`), and
+     * OpenCode 2 does the same for an assistant message that ended in error.
+     */
+    textWithReasoning: string;
+};
+export type ForeignHistoryReason = "foreign-assistant";
+/**
+ * Mark the start of one host step (one doStream). The previous step stays
+ * recorded until this one emits content, because hosts drop empty assistant
+ * turns from history.
+ */
+export declare function beginEmittedStep(sessionKey: string, conversationId: string): void;
+/** Record one stream part this provider handed to the host. */
+export declare function recordEmittedPart(sessionKey: string, conversationId: string, part: {
+    type: string;
+    delta?: unknown;
+    toolCallId?: unknown;
+}): void;
+/**
+ * Bind provenance to the conversation a Run was opened on. A reminted
+ * conversation starts with an empty record, so it never inherits the previous
+ * conversation's steps.
+ */
+export declare function trackTurnProvenance(sessionKey: string, conversationId: string): void;
+export declare function getTurnProvenance(sessionKey: string): TurnProvenance | undefined;
+export declare function restoreTurnProvenance(sessionKey: string, value: TurnProvenance): void;
+export declare function resetTurnProvenanceForTests(): void;
+export declare function serializeTurnProvenance(value: TurnProvenance): string;
+export declare function parseTurnProvenance(raw: string): TurnProvenance | undefined;
+/**
+ * Decide whether the host history moved past this Cursor conversation.
+ * Returns undefined when there is no evidence either way (no record for this
+ * conversation, or no assistant turn yet), so unknown state never forces a
+ * rebase.
+ */
+export declare function detectForeignHistory(input: {
+    sessionKey: string | undefined;
+    conversationId: string;
+    prompt: LanguageModelV3CallOptions["prompt"];
+}): ForeignHistoryReason | undefined;

package/dist/protocol/turn-provenance.js

@@ -0,0 +1,174 @@
+// A sticky Cursor conversation only knows what Cursor itself produced. When the
+// host answers a turn with another model (another provider or a local model)
+// and then comes back, resuming the old checkpoint hides that work from Cursor.
+// A direct switch between two Cursor models is not foreign history: like the
+// Cursor CLI, the next Run resumes the same conversation with the new model.
+// Remember what this provider emitted in its most recent step per OpenCode
+// session so the next fresh Run can tell whether the host's latest assistant
+// turn is ours.
+/** Mirrors MAX_TURN_STATE_SESSIONS; evicted sessions re-hydrate from disk. */
+export const MAX_PROVENANCE_SESSIONS = 256;
+// Per-session footprint stays small: a step is identified by its first tool
+// call ids and the first 4 KiB of its text (and of its reasoning plus text),
+// which is enough to tell turns apart.
+const MAX_TOOL_CALL_IDS = 64;
+const MAX_TEXT_CHARS = 4 * 1024;
+const provenanceBySession = new Map();
+function normalizeText(text) {
+    return text.replace(/\s+/g, "");
+}
+function touch(sessionKey, entry) {
+    provenanceBySession.delete(sessionKey);
+    provenanceBySession.set(sessionKey, entry);
+    while (provenanceBySession.size > MAX_PROVENANCE_SESSIONS) {
+        const oldest = provenanceBySession.keys().next().value;
+        if (!oldest)
+            break;
+        provenanceBySession.delete(oldest);
+    }
+    return entry;
+}
+function entryFor(sessionKey, conversationId) {
+    const existing = provenanceBySession.get(sessionKey);
+    if (existing && existing.conversationId === conversationId)
+        return touch(sessionKey, existing);
+    return touch(sessionKey, { conversationId, toolCallIds: [], text: "", textWithReasoning: "", stepPending: false });
+}
+function appendCapped(value, delta) {
+    return value.length < MAX_TEXT_CHARS ? (value + delta).slice(0, MAX_TEXT_CHARS) : value;
+}
+function contentEntry(sessionKey, conversationId) {
+    const entry = entryFor(sessionKey, conversationId);
+    if (entry.stepPending) {
+        entry.stepPending = false;
+        entry.toolCallIds = [];
+        entry.text = "";
+        entry.textWithReasoning = "";
+    }
+    return entry;
+}
+/**
+ * Mark the start of one host step (one doStream). The previous step stays
+ * recorded until this one emits content, because hosts drop empty assistant
+ * turns from history.
+ */
+export function beginEmittedStep(sessionKey, conversationId) {
+    entryFor(sessionKey, conversationId).stepPending = true;
+}
+/** Record one stream part this provider handed to the host. */
+export function recordEmittedPart(sessionKey, conversationId, part) {
+    if ((part.type === "text-delta" || part.type === "reasoning-delta") && typeof part.delta === "string") {
+        const delta = normalizeText(part.delta);
+        if (!delta)
+            return;
+        const entry = contentEntry(sessionKey, conversationId);
+        entry.textWithReasoning = appendCapped(entry.textWithReasoning, delta);
+        if (part.type === "text-delta")
+            entry.text = appendCapped(entry.text, delta);
+        return;
+    }
+    if (part.type === "tool-call" && typeof part.toolCallId === "string" && part.toolCallId) {
+        const entry = contentEntry(sessionKey, conversationId);
+        if (entry.toolCallIds.length < MAX_TOOL_CALL_IDS)
+            entry.toolCallIds.push(part.toolCallId);
+    }
+}
+/**
+ * Bind provenance to the conversation a Run was opened on. A reminted
+ * conversation starts with an empty record, so it never inherits the previous
+ * conversation's steps.
+ */
+export function trackTurnProvenance(sessionKey, conversationId) {
+    entryFor(sessionKey, conversationId);
+}
+export function getTurnProvenance(sessionKey) {
+    const entry = provenanceBySession.get(sessionKey);
+    if (!entry)
+        return undefined;
+    return {
+        conversationId: entry.conversationId,
+        toolCallIds: [...entry.toolCallIds],
+        text: entry.text,
+        textWithReasoning: entry.textWithReasoning,
+    };
+}
+export function restoreTurnProvenance(sessionKey, value) {
+    touch(sessionKey, { ...value, toolCallIds: [...value.toolCallIds], stepPending: false });
+}
+export function resetTurnProvenanceForTests() {
+    provenanceBySession.clear();
+}
+export function serializeTurnProvenance(value) {
+    return JSON.stringify(value);
+}
+export function parseTurnProvenance(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (typeof value.conversationId !== "string" || !value.conversationId)
+            return undefined;
+        return {
+            conversationId: value.conversationId,
+            toolCallIds: Array.isArray(value.toolCallIds)
+                ? value.toolCallIds.filter((id) => typeof id === "string").slice(0, MAX_TOOL_CALL_IDS)
+                : [],
+            text: typeof value.text === "string" ? value.text.slice(0, MAX_TEXT_CHARS) : "",
+            textWithReasoning: typeof value.textWithReasoning === "string"
+                ? value.textWithReasoning.slice(0, MAX_TEXT_CHARS)
+                : "",
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Decide whether the host history moved past this Cursor conversation.
+ * Returns undefined when there is no evidence either way (no record for this
+ * conversation, or no assistant turn yet), so unknown state never forces a
+ * rebase.
+ */
+export function detectForeignHistory(input) {
+    if (!input.sessionKey)
+        return undefined;
+    const entry = provenanceBySession.get(input.sessionKey);
+    if (!entry || entry.conversationId !== input.conversationId)
+        return undefined;
+    let lastAssistant;
+    for (let i = input.prompt.length - 1; i >= 0; i--) {
+        if (input.prompt[i].role === "assistant") {
+            lastAssistant = input.prompt[i];
+            break;
+        }
+    }
+    if (!lastAssistant || !Array.isArray(lastAssistant.content))
+        return undefined;
+    const toolCallIds = [];
+    let text = "";
+    let textWithReasoning = "";
+    for (const part of lastAssistant.content) {
+        if (part.type === "tool-call" && typeof part.toolCallId === "string")
+            toolCallIds.push(part.toolCallId);
+        if ((part.type === "text" || part.type === "reasoning") && typeof part.text === "string") {
+            const normalized = normalizeText(part.text);
+            textWithReasoning += normalized;
+            if (part.type === "text")
+                text += normalized;
+        }
+    }
+    // A turn carrying only typed reasoning gives no evidence either way.
+    if (toolCallIds.length === 0 && !text)
+        return undefined;
+    if (toolCallIds.some((id) => entry.toolCallIds.includes(id)))
+        return undefined;
+    // Compare against the latest step only: a foreign "Done." must not match an
+    // older Cursor turn that happened to contain the same words. Same model: the
+    // host keeps our reasoning typed, so its text parts match our text. After a
+    // model switch OpenCode 1.x replays that reasoning as text parts in place,
+    // so the turn matches our reasoning and text in emission order instead.
+    if (entry.text && text.slice(0, MAX_TEXT_CHARS) === entry.text)
+        return undefined;
+    if (entry.textWithReasoning && textWithReasoning.slice(0, MAX_TEXT_CHARS) === entry.textWithReasoning) {
+        return undefined;
+    }
+    return "foreign-assistant";
+}

package/dist/session.d.ts

@@ -140,10 +140,18 @@ export type CursorSession = {
     hostAgent?: string;
     /** Stable host-system + provider-guidance identity for restart validation. */
     stableSystemPromptHash?: string;
+    /** Fresh turn resumed from a stored checkpoint; a blob miss may reseed it. */
+    checkpointRebaseEligible?: boolean;
     /** Completed compaction must rebase once before resuming a normal agent. */
     postCompactionRebase?: boolean;
-    /** Last real host catalog, retained only as a lifecycle-turn fallback. */
+    /**
+     * Epoch-held host catalog for this OpenCode session. Refreshed on every
+     * `doStream` (including held-Run continuation) so exec #36 and permission
+     * can see tools that connected after Run open. Also the lifecycle-turn fallback.
+     */
     toolCatalog?: OpencodeToolDef[];
+    /** Configured MCP server ids used to split flattened host tool names. */
+    knownMcpServers?: string[];
     stream: BidiStream;
     frames: AsyncIterator<Frame>;
     pending: Map<number, PendingExec>;

package/dist/shared.d.ts

@@ -1,5 +1,12 @@
 export declare const CURSOR_API_HOST = "api2.cursor.sh";
 export declare const CURSOR_WEBSITE_HOST = "cursor.com";
+/**
+ * Production OAuth client id Cursor's IDE sends on `POST /oauth/token`
+ * (Cursor 3.17.19 `workbench.desktop.main.js`, `cursorCreds.authClientId` for
+ * `backendUrl` `https://api2.cursor.sh`). The IDE's non-production id is not
+ * used: a custom `CURSOR_API_BASE_URL` keeps this one.
+ */
+export declare const CURSOR_OAUTH_CLIENT_ID = "KbZUR41cY7W6zRSdpSUJ7I7mLYBKOCmB";
 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. */

package/dist/shared.js

@@ -1,5 +1,12 @@
 export const CURSOR_API_HOST = "api2.cursor.sh";
 export const CURSOR_WEBSITE_HOST = "cursor.com";
+/**
+ * Production OAuth client id Cursor's IDE sends on `POST /oauth/token`
+ * (Cursor 3.17.19 `workbench.desktop.main.js`, `cursorCreds.authClientId` for
+ * `backendUrl` `https://api2.cursor.sh`). The IDE's non-production id is not
+ * used: a custom `CURSOR_API_BASE_URL` keeps this one.
+ */
+export const CURSOR_OAUTH_CLIENT_ID = "KbZUR41cY7W6zRSdpSUJ7I7mLYBKOCmB";
 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. */

package/package.json

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

package/dist/context/agents.d.ts

@@ -1,12 +0,0 @@
-export type CollectedAgent = {
-    fullPath: string;
-    name: string;
-    description: string;
-    prompt: string;
-};
-/**
- * Custom agents from the active OpenCode-compatible config roots. A host bridge may
- * install a host-neutral bridge before loading this module; without one this
- * remains the direct OpenCode discovery path.
- */
-export declare function collectAgents(workspaceRoot: string): Promise<CollectedAgent[]>;

package/dist/context/agents.js

@@ -1,136 +0,0 @@
-import { readdir, readFile, realpath, stat } from "node:fs/promises";
-import path from "node:path";
-import { opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
-async function exists(p) {
-    try {
-        await stat(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function parseAgentMarkdown(raw, fallbackName) {
-    let name = fallbackName;
-    let description = "";
-    let body = raw;
-    if (raw.startsWith("---")) {
-        const end = raw.indexOf("\n---", 3);
-        if (end >= 0) {
-            const fm = raw.slice(3, end).trim();
-            body = raw.slice(end + 4).replace(/^\n/, "");
-            for (const line of fm.split("\n")) {
-                const m = line.match(/^(\w+):\s*(.*)$/);
-                if (!m)
-                    continue;
-                let val = m[2].trim();
-                if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-                    val = val.slice(1, -1);
-                }
-                if (m[1] === "name")
-                    name = val;
-                if (m[1] === "description")
-                    description = val;
-            }
-        }
-    }
-    return { name, description, prompt: body.slice(0, 20_000) };
-}
-function uniquePaths(paths) {
-    const seen = new Set();
-    return paths.filter((value) => {
-        const normalized = path.resolve(value);
-        if (seen.has(normalized))
-            return false;
-        seen.add(normalized);
-        return true;
-    });
-}
-/**
- * Read one host config root's `agent/` and `agents/` trees. Host loaders use
- * both spellings and recurse through nested markdown files. Directory symlinks
- * are followed with realpath cycle detection, matching host behavior without
- * allowing a symlink loop to hang context construction.
- */
-async function scanAgentRoot(root, out) {
-    if (!(await exists(root)))
-        return;
-    const visitedDirs = new Set();
-    const scanDir = async (dir, relativePrefix) => {
-        let canonical;
-        try {
-            canonical = await realpath(dir);
-        }
-        catch {
-            return;
-        }
-        if (visitedDirs.has(canonical))
-            return;
-        visitedDirs.add(canonical);
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-            entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            const relative = path.join(relativePrefix, entry.name);
-            let isDirectory = entry.isDirectory();
-            let isFile = entry.isFile();
-            if (entry.isSymbolicLink()) {
-                try {
-                    const target = await stat(full);
-                    isDirectory = target.isDirectory();
-                    isFile = target.isFile();
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (isDirectory) {
-                await scanDir(full, relative);
-                continue;
-            }
-            if (!isFile || !entry.name.endsWith(".md"))
-                continue;
-            try {
-                const raw = await readFile(full, "utf-8");
-                const fallbackName = relative.replace(/\\/g, "/").replace(/\.md$/, "");
-                const parsed = parseAgentMarkdown(raw, fallbackName);
-                if (!out.has(parsed.name)) {
-                    out.set(parsed.name, {
-                        fullPath: path.resolve(full),
-                        name: parsed.name,
-                        description: parsed.description,
-                        prompt: parsed.prompt,
-                    });
-                }
-            }
-            catch {
-                /* skip unreadable or malformed files without failing context build */
-            }
-        }
-    };
-    // Scan singular before plural, then let root ordering establish host
-    // precedence. This is deterministic and mirrors the hosts' brace glob.
-    await scanDir(path.join(root, "agent"), "agent");
-    await scanDir(path.join(root, "agents"), "agents");
-}
-/**
- * Custom agents from the active OpenCode-compatible config roots. A host bridge may
- * install a host-neutral bridge before loading this module; without one this
- * remains the direct OpenCode discovery path.
- */
-export async function collectAgents(workspaceRoot) {
-    const out = new Map();
-    const roots = uniquePaths([
-        ...opencodeProjectConfigDirs(workspaceRoot),
-        ...opencodeGlobalConfigDirs(),
-    ]);
-    for (const root of roots)
-        await scanAgentRoot(root, out);
-    return [...out.values()];
-}

package/dist/context/skills.d.ts

@@ -1,11 +0,0 @@
-export type CollectedSkill = {
-    fullPath: string;
-    name: string;
-    description: string;
-    content: string;
-};
-/**
- * Discover skills the way OpenCode does: `.opencode/skills`, global opencode,
- * plus `.claude/skills` and `.agents/skills` (project + home).
- */
-export declare function collectSkills(workspaceRoot: string, worktree: string): Promise<CollectedSkill[]>;

package/dist/context/skills.js

@@ -1,110 +0,0 @@
-import { readdir, readFile, stat } from "node:fs/promises";
-import path from "node:path";
-import { homedir } from "node:os";
-import { opencodeGlobalConfigDirs, opencodeProjectConfigDirs } from "./paths.js";
-async function exists(p) {
-    try {
-        await stat(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function parseFrontmatter(raw) {
-    if (!raw.startsWith("---"))
-        return { body: raw };
-    const end = raw.indexOf("\n---", 3);
-    if (end < 0)
-        return { body: raw };
-    const fm = raw.slice(3, end).trim();
-    const body = raw.slice(end + 4).replace(/^\n/, "");
-    let name;
-    let description;
-    for (const line of fm.split("\n")) {
-        const m = line.match(/^(\w+):\s*(.*)$/);
-        if (!m)
-            continue;
-        const key = m[1];
-        let val = m[2].trim();
-        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-            val = val.slice(1, -1);
-        }
-        if (key === "name")
-            name = val;
-        if (key === "description")
-            description = val;
-    }
-    return { name, description, body };
-}
-async function loadSkillFile(file) {
-    try {
-        const raw = await readFile(file, "utf-8");
-        const { name, description, body } = parseFrontmatter(raw);
-        const dirName = path.basename(path.dirname(file));
-        return {
-            fullPath: path.resolve(file),
-            name: name || dirName,
-            description: description || "",
-            content: body.slice(0, 20_000),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-async function scanSkillsRoot(root, out) {
-    if (!(await exists(root)))
-        return;
-    let entries;
-    try {
-        entries = await readdir(root);
-    }
-    catch {
-        return;
-    }
-    entries.sort();
-    for (const name of entries) {
-        const skillMd = path.join(root, name, "SKILL.md");
-        if (!(await exists(skillMd)))
-            continue;
-        const skill = await loadSkillFile(skillMd);
-        if (!skill)
-            continue;
-        if (!out.has(skill.name))
-            out.set(skill.name, skill);
-    }
-}
-async function walkAncestorsFor(dir, rel, stop, out) {
-    let cur = path.resolve(dir);
-    const root = path.resolve(stop);
-    for (;;) {
-        await scanSkillsRoot(path.join(cur, rel), out);
-        if (cur === root)
-            break;
-        const parent = path.dirname(cur);
-        if (parent === cur)
-            break;
-        cur = parent;
-    }
-}
-/**
- * Discover skills the way OpenCode does: `.opencode/skills`, global opencode,
- * plus `.claude/skills` and `.agents/skills` (project + home).
- */
-export async function collectSkills(workspaceRoot, worktree) {
-    const out = new Map();
-    const home = homedir();
-    for (const projectDir of opencodeProjectConfigDirs(workspaceRoot)) {
-        const relative = path.relative(workspaceRoot, projectDir);
-        await walkAncestorsFor(workspaceRoot, path.join(relative, "skills"), worktree, out);
-    }
-    for (const globalDir of opencodeGlobalConfigDirs()) {
-        await scanSkillsRoot(path.join(globalDir, "skills"), out);
-    }
-    await walkAncestorsFor(workspaceRoot, path.join(".claude", "skills"), worktree, out);
-    await scanSkillsRoot(path.join(home, ".claude", "skills"), out);
-    await walkAncestorsFor(workspaceRoot, path.join(".agents", "skills"), worktree, out);
-    await scanSkillsRoot(path.join(home, ".agents", "skills"), out);
-    return [...out.values()];
-}