cursor-opencode-provider 0.2.1 → 0.2.2

package/dist/plugin.js

@@ -1,4 +1,4 @@
-import { CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
+import { CURSOR_COMPACTION_OPTION, CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
 import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtPayload } from "./auth.js";
 import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, readCache, discoverModels, isCacheFresh } from "./models.js";
 import { opencodeGlobalCacheDir } from "./context/paths.js";
@@ -129,6 +129,11 @@ export function modelInfoToConfig(mi, options = {}) {
     const context = contextTier === "long"
         ? (mi.maxContextForMaxMode ?? 1_000_000)
         : (mi.maxContext ?? 200_000);
+    // OpenCode's overflow/compaction/UI use limit.context; generation and
+    // thinking budgets use limit.output. models.dev 1M peers advertise
+    // 64k–128k output — a tiny cap makes long-context sessions feel broken
+    // even when the 1M input window is correct.
+    const output = contextTier === "long" ? 128_000 : 32_000;
     const config = {
         name,
         reasoning: mi.supportsThinking ?? false,
@@ -136,7 +141,7 @@ export function modelInfoToConfig(mi, options = {}) {
         temperature: false,
         limit: {
             context,
-            output: 4096,
+            output,
         },
     };
     const variantConfig = modelInfoVariants(mi, variants);
@@ -306,6 +311,16 @@ export async function CursorPlugin(input) {
         return cached?.models.length ? modelsToConfig(cached.models) : {};
     }
     return {
+        async "chat.params"(hookInput, output) {
+            if (hookInput.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            // 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.
+            if (hookInput.agent === "compaction") {
+                output.options[CURSOR_COMPACTION_OPTION] = true;
+            }
+        },
         async config(cfg) {
             cfg.provider ??= {};
             const models = await loadModels();

package/dist/protocol/blob-store.d.ts

@@ -10,6 +10,8 @@
 export declare function setConversationBlob(conversationId: string, blobId: Uint8Array, blobData: Uint8Array): string;
 export declare function getConversationBlob(conversationId: string, blobId: Uint8Array): Uint8Array | undefined;
 export declare function conversationBlobCount(conversationId: string): number;
+/** Drop all blobs for a conversation (compaction conversation reset). */
+export declare function clearConversationBlobs(conversationId: string): void;
 /** SHA-256 content hashes are 32 non-text bytes — never echo those as content. */
 export declare function isBlobIdHash(blobId: Uint8Array): boolean;
 export declare function resetConversationBlobsForTests(): void;

package/dist/protocol/blob-store.js

@@ -34,6 +34,10 @@ export function getConversationBlob(conversationId, blobId) {
 export function conversationBlobCount(conversationId) {
     return byConversation.get(conversationId)?.size ?? 0;
 }
+/** Drop all blobs for a conversation (compaction conversation reset). */
+export function clearConversationBlobs(conversationId) {
+    byConversation.delete(conversationId);
+}
 /** SHA-256 content hashes are 32 non-text bytes — never echo those as content. */
 export function isBlobIdHash(blobId) {
     if (blobId.length !== 32)

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

@@ -0,0 +1,18 @@
+export declare const MAX_ACTIVE_CONVERSATION_BINDINGS = 256;
+export declare function resetConversationBindingsForTests(): void;
+/** Deterministic UUID (version-4 shape) from an arbitrary session key. */
+export declare function sessionIdToUuid(sessionId: string): string;
+/** Current Cursor conversation_id for an OpenCode session key, creating the default binding if needed. */
+export declare function peekConversationId(sessionKey: string): string;
+/**
+ * Resolve the Cursor conversation_id for this OpenCode session.
+ * When `reset` is true (compaction/summary), discard prior Cursor state and
+ * mint a new id so TurnEnded cache_read cannot keep overflowing OpenCode.
+ */
+export declare function bindConversationId(sessionKey: string | undefined, opts?: {
+    reset?: boolean;
+}): {
+    conversationId: string;
+    reset: boolean;
+    previousId?: string;
+};

package/dist/protocol/conversation-bind.js

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { clearCheckpoint } from "./checkpoint.js";
+import { clearConversationBlobs } from "./blob-store.js";
+/**
+ * OpenCode session key → active Cursor conversation_id.
+ *
+ * Normally the binding is the deterministic UUID from the OpenCode session id
+ * (CLI-shaped sticky conversation). Compaction/summary turns mint a fresh id
+ * and drop the prior checkpoint + blobs so Cursor no longer bills the old
+ * cached conversation against OpenCode's newly compacted prompt.
+ */
+const activeBySession = new Map();
+export const MAX_ACTIVE_CONVERSATION_BINDINGS = 256;
+function rememberConversation(sessionKey, conversationId) {
+    // Map insertion order is the LRU order. Refresh existing sessions on use.
+    activeBySession.delete(sessionKey);
+    activeBySession.set(sessionKey, conversationId);
+    while (activeBySession.size > MAX_ACTIVE_CONVERSATION_BINDINGS) {
+        const oldest = activeBySession.entries().next().value;
+        if (!oldest)
+            break;
+        activeBySession.delete(oldest[0]);
+        clearCheckpoint(oldest[1]);
+        clearConversationBlobs(oldest[1]);
+    }
+}
+export function resetConversationBindingsForTests() {
+    activeBySession.clear();
+}
+/** Deterministic UUID (version-4 shape) from an arbitrary session key. */
+export function sessionIdToUuid(sessionId) {
+    const hash = createHash("sha256").update(`cursor-opencode-provider:conv:${sessionId}`).digest();
+    const bytes = Buffer.from(hash.subarray(0, 16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+/** Current Cursor conversation_id for an OpenCode session key, creating the default binding if needed. */
+export function peekConversationId(sessionKey) {
+    let id = activeBySession.get(sessionKey);
+    if (!id) {
+        id = sessionIdToUuid(sessionKey);
+    }
+    rememberConversation(sessionKey, id);
+    return id;
+}
+/**
+ * Resolve the Cursor conversation_id for this OpenCode session.
+ * When `reset` is true (compaction/summary), discard prior Cursor state and
+ * mint a new id so TurnEnded cache_read cannot keep overflowing OpenCode.
+ */
+export function bindConversationId(sessionKey, opts) {
+    if (!sessionKey) {
+        return { conversationId: crypto.randomUUID(), reset: !!opts?.reset };
+    }
+    if (opts?.reset) {
+        const previousId = activeBySession.get(sessionKey) ?? sessionIdToUuid(sessionKey);
+        clearCheckpoint(previousId);
+        clearConversationBlobs(previousId);
+        const conversationId = crypto.randomUUID();
+        rememberConversation(sessionKey, conversationId);
+        return { conversationId, reset: true, previousId };
+    }
+    return { conversationId: peekConversationId(sessionKey), reset: false };
+}

package/dist/protocol/interactions.d.ts

@@ -0,0 +1,23 @@
+export type InteractionQueryWireInfo = {
+    id?: number;
+    variantField?: number;
+    variantName?: string;
+};
+export type HandledInteraction = {
+    id: number;
+    variantField: number;
+    variantName: string;
+    outcome: "rejected" | "acknowledged" | "failed";
+    reply: Uint8Array;
+};
+export declare class UnsupportedInteractionQueryError extends Error {
+    constructor(info: InteractionQueryWireInfo);
+}
+/**
+ * Inspect the raw wrapper as well as the decoded object. protobufjs drops
+ * fields introduced by newer Cursor schemas; raw inspection lets us fail fast
+ * instead of accidentally restoring the heartbeat-only deadlock.
+ */
+export declare function inspectInteractionQueryWire(agentServerPayload: Uint8Array): InteractionQueryWireInfo;
+/** Build the immediate typed response required by Cursor's Run RPC. */
+export declare function handleInteractionQuery(query: Record<string, unknown>, agentServerPayload: Uint8Array): HandledInteraction;

package/dist/protocol/interactions.js

@@ -0,0 +1,136 @@
+import { encodeMessage } from "./messages.js";
+import { readAllFields } from "./struct.js";
+const HEADLESS_REASON = "This Cursor interaction requires UI approval and is not available through the OpenCode provider.";
+const variantNames = {
+    2: "web_search_request_query",
+    3: "ask_question_interaction_query",
+    4: "switch_mode_request_query",
+    7: "create_plan_request_query",
+    8: "setup_vm_environment_args",
+    9: "web_fetch_request_query",
+    10: "pr_management_request_query",
+    11: "mcp_auth_request_query",
+    12: "generate_image_request_query",
+    13: "replace_env_args",
+    14: "connect_scm_request_query",
+};
+export class UnsupportedInteractionQueryError extends Error {
+    constructor(info) {
+        const variant = info.variantField === undefined
+            ? "missing variant"
+            : `unsupported variant field #${info.variantField}`;
+        const id = info.id === undefined ? "missing id" : `id=${info.id}`;
+        super(`Cursor interaction query cannot be handled (${id}, ${variant})`);
+        this.name = "UnsupportedInteractionQueryError";
+    }
+}
+/**
+ * Inspect the raw wrapper as well as the decoded object. protobufjs drops
+ * fields introduced by newer Cursor schemas; raw inspection lets us fail fast
+ * instead of accidentally restoring the heartbeat-only deadlock.
+ */
+export function inspectInteractionQueryWire(agentServerPayload) {
+    const queryBytes = readAllFields(agentServerPayload)
+        .find((field) => field.fn === 7 && field.wt === 2)?.bytes;
+    if (!queryBytes)
+        return {};
+    // InteractionQuery.id is a proto3 uint32. Cursor commonly uses id=0, whose
+    // default scalar value is omitted from the wire; absence therefore means
+    // zero, not a malformed/missing correlation id.
+    let id = 0;
+    let variantField;
+    for (const field of readAllFields(queryBytes)) {
+        if (field.fn === 1 && field.wt === 0)
+            id = field.varint;
+        else if (field.wt === 2 && variantField === undefined)
+            variantField = field.fn;
+    }
+    return {
+        id,
+        variantField,
+        variantName: variantField === undefined ? undefined : variantNames[variantField],
+    };
+}
+/** Build the immediate typed response required by Cursor's Run RPC. */
+export function handleInteractionQuery(query, agentServerPayload) {
+    const info = inspectInteractionQueryWire(agentServerPayload);
+    if (info.id === undefined || info.variantField === undefined || !info.variantName) {
+        throw new UnsupportedInteractionQueryError(info);
+    }
+    if (typeof query.id === "number" && query.id !== info.id) {
+        throw new Error(`Cursor interaction query id mismatch: decoded=${query.id} wire=${info.id}`);
+    }
+    let response;
+    let outcome;
+    switch (info.variantField) {
+        case 2:
+            response = { web_search_request_response: { rejected: { reason: HEADLESS_REASON } } };
+            outcome = "rejected";
+            break;
+        case 3:
+            response = {
+                ask_question_interaction_response: {
+                    result: { rejected: { reason: "Questions must be asked through OpenCode's question tool." } },
+                },
+            };
+            outcome = "rejected";
+            break;
+        case 4:
+            response = { switch_mode_request_response: { rejected: { reason: HEADLESS_REASON } } };
+            outcome = "rejected";
+            break;
+        case 7:
+            // Cursor CLI's headless fallback acknowledges plan creation without a
+            // client-side URI; the plan remains in conversation state/checkpoints.
+            response = { create_plan_request_response: { result: { success: {}, plan_uri: "" } } };
+            outcome = "acknowledged";
+            break;
+        case 8:
+            // OpenCode owns the local environment; there is no Cursor VM to create.
+            response = { setup_vm_environment_result: { success: {} } };
+            outcome = "acknowledged";
+            break;
+        case 9:
+            response = { web_fetch_request_response: { rejected: { reason: HEADLESS_REASON } } };
+            outcome = "rejected";
+            break;
+        case 10:
+            response = { pr_management_result: { rejected: { reason: HEADLESS_REASON } } };
+            outcome = "rejected";
+            break;
+        case 11:
+            response = { mcp_auth_request_response: { rejected: { reason: HEADLESS_REASON } } };
+            outcome = "rejected";
+            break;
+        case 12:
+            response = { generate_image_request_response: { rejected: { reason: HEADLESS_REASON } } };
+            outcome = "rejected";
+            break;
+        case 13:
+            response = {
+                replace_env_result: {
+                    failure: {
+                        error_message: "Environment replacement is not supported by the OpenCode provider.",
+                        setup_logs: "",
+                    },
+                },
+            };
+            outcome = "failed";
+            break;
+        case 14:
+            response = { connect_scm_request_response: { rejected: { reason: HEADLESS_REASON } } };
+            outcome = "rejected";
+            break;
+        default:
+            throw new UnsupportedInteractionQueryError(info);
+    }
+    return {
+        id: info.id,
+        variantField: info.variantField,
+        variantName: info.variantName,
+        outcome,
+        reply: encodeMessage("AgentClientMessage", {
+            interaction_response: { id: info.id, ...response },
+        }),
+    };
+}