opencode-cursor-provider 0.1.0

package/dist/bridge/binding.js

@@ -0,0 +1,59 @@
+import { extendsCheckpoint } from "./conversation.js";
+export function route(input) {
+    if (input.scope === undefined)
+        return "ONE_SHOT";
+    if (input.binding === undefined)
+        return "FRESH";
+    if (input.binding.modelID !== input.modelID)
+        return "FRESH";
+    if (input.binding.cwd !== input.scope.cwd)
+        return "FRESH";
+    if (!sameParams(input.binding.params, input.params))
+        return "FRESH";
+    if (input.binding.mode !== input.mode)
+        return "FRESH";
+    if (!sameAgentOptions(input.binding.agentOptions, input.agentOptions))
+        return "FRESH";
+    if (!extendsCheckpoint(input.conversation, input.binding.checkpoint))
+        return "FRESH";
+    return "RESUME";
+}
+function sameAgentOptions(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (sameSet(left.tools, right.tools) &&
+        sameSet(left.disallowedTools, right.disallowedTools) &&
+        left.sandboxOptions?.enabled === right.sandboxOptions?.enabled &&
+        left.autoReview === right.autoReview &&
+        sameSet(left.settingSources, right.settingSources));
+}
+function sameSet(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    const leftSet = new Set(left);
+    const rightSet = new Set(right);
+    return leftSet.size === rightSet.size && [...leftSet].every((value) => rightSet.has(value));
+}
+function sameParams(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    if (left.length !== right.length)
+        return false;
+    const leftValues = left.map((param) => JSON.stringify([param.id, param.value])).sort();
+    const rightValues = right.map((param) => JSON.stringify([param.id, param.value])).sort();
+    return leftValues.every((value, index) => value === rightValues[index]);
+}
+export function createBindingStore() {
+    const bindings = new Map();
+    return {
+        get(sessionID) {
+            return bindings.get(sessionID);
+        },
+        put(binding) {
+            bindings.set(binding.sessionID, binding);
+        },
+        drop(sessionID) {
+            bindings.delete(sessionID);
+        },
+    };
+}

package/dist/bridge/bridge.d.ts

@@ -0,0 +1,16 @@
+import type { CursorLink } from "../auth/link.ts";
+import type { CursorModelDescriptor } from "../catalog/catalog.ts";
+import { type BindingStore, type TurnScope } from "./binding.ts";
+import { type TurnRequest } from "./turn.ts";
+import type { TurnEvent } from "./translate.ts";
+export type { TurnRequest } from "./turn.ts";
+export interface SessionAgentBridge {
+    annotate(system: string[], scope: TurnScope): string[];
+    turn(request: TurnRequest): AsyncIterable<TurnEvent>;
+}
+export declare function createSessionAgentBridge(input: {
+    link: CursorLink;
+    models: () => readonly CursorModelDescriptor[];
+    bindings?: BindingStore;
+    clock?: () => number;
+}): SessionAgentBridge;

package/dist/bridge/bridge.js

@@ -0,0 +1,21 @@
+import { createBindingStore } from "./binding.js";
+import { stampSystem } from "./correlation.js";
+import { createLock } from "./lock.js";
+import { createTurnRunner } from "./turn.js";
+export function createSessionAgentBridge(input) {
+    const runTurn = createTurnRunner({
+        link: input.link,
+        models: input.models,
+        bindings: input.bindings ?? createBindingStore(),
+        clock: input.clock ?? Date.now,
+        lock: createLock(),
+    });
+    return {
+        annotate(system, scope) {
+            return stampSystem(system, scope);
+        },
+        turn(request) {
+            return runTurn(request);
+        },
+    };
+}

package/dist/bridge/conversation.d.ts

@@ -0,0 +1,64 @@
+import type { SDKUserMessage } from "@cursor/sdk";
+export interface CursorImage {
+    readonly data: string;
+    readonly mimeType: string;
+}
+export type UserPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "image";
+    readonly image: CursorImage;
+};
+export type AssistantPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "reasoning";
+    readonly text: string;
+} | {
+    readonly type: "tool-call";
+    readonly id: string;
+    readonly name: string;
+    readonly input: string;
+} | {
+    readonly type: "tool-result";
+    readonly id: string;
+    readonly name: string;
+    readonly output: readonly UserPart[];
+    readonly isError: boolean;
+};
+export type ToolPart = Extract<AssistantPart, {
+    type: "tool-result";
+}> | {
+    readonly type: "tool-approval";
+    readonly id: string;
+    readonly approved: boolean;
+    readonly reason?: string;
+};
+export type ConversationTurn = {
+    readonly role: "user";
+    readonly parts: readonly UserPart[];
+} | {
+    readonly role: "assistant";
+    readonly parts: readonly AssistantPart[];
+} | {
+    readonly role: "tool";
+    readonly parts: readonly ToolPart[];
+};
+export interface Conversation {
+    readonly system: readonly string[];
+    readonly turns: readonly ConversationTurn[];
+}
+export interface ConversationCheckpoint {
+    readonly system: string;
+    readonly turns: readonly string[];
+}
+export declare function render(system: readonly string[], turns: readonly ConversationTurn[]): string;
+export declare function cursorMessage(system: readonly string[], turns: readonly ConversationTurn[]): string | SDKUserMessage;
+export declare function checkpointOf(conversation: Conversation): ConversationCheckpoint;
+export declare function resumeTurn(conversation: Conversation, checkpoint: ConversationCheckpoint): Extract<ConversationTurn, {
+    role: "user";
+}> | undefined;
+export declare function extendsCheckpoint(conversation: Conversation, checkpoint: ConversationCheckpoint): boolean;
+export declare function canonicalJson(value: unknown): string;

package/dist/bridge/conversation.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+export function render(system, turns) {
+    return renderCursorMessage(system, turns).text;
+}
+export function cursorMessage(system, turns) {
+    const message = renderCursorMessage(system, turns);
+    return message.images === undefined ? message.text : message;
+}
+export function checkpointOf(conversation) {
+    return {
+        system: digest(conversation.system),
+        turns: conversation.turns.map(digest),
+    };
+}
+export function resumeTurn(conversation, checkpoint) {
+    if (digest(conversation.system) !== checkpoint.system)
+        return undefined;
+    if (conversation.turns.length !== checkpoint.turns.length + 1)
+        return undefined;
+    for (let index = 0; index < checkpoint.turns.length; index += 1) {
+        const turn = conversation.turns[index];
+        if (turn === undefined || digest(turn) !== checkpoint.turns[index])
+            return undefined;
+    }
+    const suffix = conversation.turns.at(-1);
+    return suffix?.role === "user" ? suffix : undefined;
+}
+export function extendsCheckpoint(conversation, checkpoint) {
+    return resumeTurn(conversation, checkpoint) !== undefined;
+}
+export function canonicalJson(value) {
+    return JSON.stringify(ordered(value)) ?? "null";
+}
+function renderCursorMessage(system, turns) {
+    const sections = [];
+    const images = [];
+    for (const instruction of system)
+        sections.push(`System: ${instruction}`);
+    for (const turn of turns) {
+        const role = turn.role === "user" ? "User" : turn.role === "assistant" ? "Assistant" : "Tool";
+        const parts = turn.parts.map((part) => renderPart(part, images));
+        sections.push(`${role}: ${parts.join("\n\n")}`);
+    }
+    const text = sections.join("\n\n");
+    return images.length === 0 ? { text } : { text, images };
+}
+function renderPart(part, images) {
+    switch (part.type) {
+        case "text":
+            return part.text;
+        case "image":
+            images.push(part.image);
+            return `[Image ${images.length}: ${part.image.mimeType}]`;
+        case "reasoning":
+            return `[Reasoning]\n${part.text}`;
+        case "tool-call":
+            return `[Tool call ${part.name} (${part.id})]\n${part.input}`;
+        case "tool-result":
+            return [
+                `[Tool ${part.isError ? "error" : "result"} ${part.name} (${part.id})]`,
+                ...part.output.map((output) => renderPart(output, images)),
+            ].join("\n");
+        case "tool-approval":
+            return `[Tool approval ${part.id}]\n${part.approved ? "approved" : "denied"}${part.reason ? `: ${part.reason}` : ""}`;
+        default: {
+            const _exhaustive = part;
+            return _exhaustive;
+        }
+    }
+}
+function digest(value) {
+    return createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+function ordered(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value !== "object")
+        return String(value);
+    if (Array.isArray(value))
+        return value.map(ordered);
+    return Object.fromEntries(Object.keys(value)
+        .sort()
+        .map((key) => [key, ordered(Object.getOwnPropertyDescriptor(value, key)?.value)]));
+}

package/dist/bridge/correlation.d.ts

@@ -0,0 +1,10 @@
+import type { TurnScope } from "./binding.ts";
+export declare const SENTINEL_VERSION = 1;
+export declare function encodeSentinel(scope: TurnScope): string;
+export declare function decodeSentinel(text: string): TurnScope | undefined;
+export declare function stampSystem(system: string[], scope: TurnScope): string[];
+export declare function extractScope(system: readonly string[]): {
+    readonly scope: TurnScope | undefined;
+    readonly system: readonly string[];
+};
+export declare function sessionFromId(sessionID: string, cwd: string): TurnScope;

package/dist/bridge/correlation.js

@@ -0,0 +1,52 @@
+import { asSessionID } from "../ids.js";
+export const SENTINEL_VERSION = 1;
+const PREFIX = `<!-- opencode-cursor-provider:${SENTINEL_VERSION}:`;
+export function encodeSentinel(scope) {
+    return `${PREFIX}${JSON.stringify({ sessionID: scope.sessionID, cwd: scope.cwd })} -->`;
+}
+export function decodeSentinel(text) {
+    const start = text.indexOf(PREFIX);
+    if (start === -1)
+        return undefined;
+    const jsonStart = start + PREFIX.length;
+    const end = text.indexOf(" -->", jsonStart);
+    if (end === -1)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text.slice(jsonStart, end));
+        if (typeof parsed !== "object" || parsed === null)
+            return undefined;
+        const record = parsed;
+        if (typeof record.sessionID !== "string" || typeof record.cwd !== "string")
+            return undefined;
+        if (record.sessionID.length === 0 || record.cwd.length === 0)
+            return undefined;
+        return { sessionID: asSessionID(record.sessionID), cwd: record.cwd };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function stampSystem(system, scope) {
+    const marker = encodeSentinel(scope);
+    if (system.some((line) => line.includes(PREFIX))) {
+        return system.map((line) => (line.includes(PREFIX) ? marker : line));
+    }
+    return [...system, marker];
+}
+export function extractScope(system) {
+    let scope;
+    const cleaned = [];
+    for (const line of system) {
+        const found = decodeSentinel(line);
+        if (found) {
+            scope = found;
+            continue;
+        }
+        cleaned.push(line);
+    }
+    return { scope, system: cleaned };
+}
+export function sessionFromId(sessionID, cwd) {
+    return { sessionID: asSessionID(sessionID), cwd };
+}

package/dist/bridge/lock.d.ts

@@ -0,0 +1,4 @@
+export interface KeyedLock {
+    acquire(key: string): Promise<() => void>;
+}
+export declare function createLock(): KeyedLock;

package/dist/bridge/lock.js

@@ -0,0 +1,24 @@
+export function createLock() {
+    const locks = new Map();
+    return {
+        async acquire(key) {
+            const previous = locks.get(key) ?? Promise.resolve();
+            let releaseCurrent = () => { };
+            const current = new Promise((resolve) => {
+                releaseCurrent = resolve;
+            });
+            const queued = previous.then(() => current);
+            locks.set(key, queued);
+            await previous;
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                releaseCurrent();
+                if (locks.get(key) === queued)
+                    locks.delete(key);
+            };
+        },
+    };
+}

package/dist/bridge/response-journal.d.ts

@@ -0,0 +1,7 @@
+import { type AssistantPart } from "./conversation.ts";
+import type { TurnEvent } from "./translate.ts";
+export interface ResponseJournal {
+    accept(event: TurnEvent): TurnEvent | undefined;
+    parts(): readonly AssistantPart[];
+}
+export declare function createResponseJournal(): ResponseJournal;

package/dist/bridge/response-journal.js

@@ -0,0 +1,49 @@
+import { canonicalJson } from "./conversation.js";
+export function createResponseJournal() {
+    const parts = [];
+    const toolCalls = new Set();
+    const toolResults = new Set();
+    return {
+        accept(event) {
+            if (event.type === "text" || event.type === "reasoning") {
+                const previous = parts.at(-1);
+                if (previous?.type === event.type) {
+                    parts.splice(-1, 1, { type: event.type, text: previous.text + event.delta });
+                }
+                else {
+                    parts.push({ type: event.type, text: event.delta });
+                }
+                return event;
+            }
+            if (event.type === "tool-call") {
+                if (toolCalls.has(event.id))
+                    return undefined;
+                toolCalls.add(event.id);
+                parts.push({ type: "tool-call", id: event.id, name: event.name, input: canonicalJson(event.input) });
+                return event;
+            }
+            if (event.type === "tool-result") {
+                if (toolResults.has(event.id))
+                    return undefined;
+                toolResults.add(event.id);
+                parts.push({
+                    type: "tool-result",
+                    id: event.id,
+                    name: event.name,
+                    output: [
+                        {
+                            type: "text",
+                            text: typeof event.result === "string" ? event.result : canonicalJson(event.result),
+                        },
+                    ],
+                    isError: event.isError,
+                });
+                return event;
+            }
+            return event;
+        },
+        parts() {
+            return parts;
+        },
+    };
+}

package/dist/bridge/translate.d.ts

@@ -0,0 +1,60 @@
+import type { SDKMessage } from "@cursor/sdk";
+import type { CursorPluginError } from "../errors.ts";
+export type TurnEvent = {
+    readonly type: "raw";
+    readonly value: SDKMessage;
+} | {
+    readonly type: "response-metadata";
+    readonly id: string;
+    readonly timestamp?: number;
+    readonly modelId?: string;
+} | {
+    readonly type: "text";
+    readonly delta: string;
+} | {
+    readonly type: "reasoning";
+    readonly delta: string;
+} | {
+    readonly type: "tool-call";
+    readonly id: string;
+    readonly name: string;
+    readonly input: JsonValue;
+} | {
+    readonly type: "tool-result";
+    readonly id: string;
+    readonly name: string;
+    readonly result: NonNullJsonValue;
+    readonly isError: boolean;
+} | {
+    readonly type: "usage";
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly reasoning: number;
+    readonly total: number;
+} | {
+    readonly type: "done";
+    readonly reason: "stop" | "length" | "aborted";
+    readonly metadata?: {
+        readonly runId: string;
+        readonly requestId?: string;
+        readonly durationMs?: number;
+        readonly modelId?: string;
+        readonly git?: readonly {
+            readonly repoUrl: string;
+            readonly branch?: string;
+            readonly prUrl?: string;
+        }[];
+    };
+} | {
+    readonly type: "failed";
+    readonly error: CursorPluginError;
+};
+type JsonValue = null | string | number | boolean | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type NonNullJsonValue = Exclude<JsonValue, null>;
+export declare function translate(message: SDKMessage): readonly TurnEvent[];
+export declare function createMessageTranslator(): (message: SDKMessage) => readonly TurnEvent[];
+export {};

package/dist/bridge/translate.js

@@ -0,0 +1,188 @@
+export function translate(message) {
+    return translateMessage(message, new Map());
+}
+export function createMessageTranslator() {
+    const toolInputs = new Map();
+    return (message) => translateMessage(message, toolInputs);
+}
+function translateMessage(message, toolInputs) {
+    switch (message.type) {
+        case "assistant": {
+            const events = [];
+            for (const block of message.message.content) {
+                if (block.type === "text" && block.text.length > 0) {
+                    events.push({ type: "text", delta: block.text });
+                }
+                if (block.type === "tool_use")
+                    toolInputs.set(block.id, block.input);
+            }
+            return events;
+        }
+        case "thinking":
+            return message.text.length > 0 ? [{ type: "reasoning", delta: message.text }] : [];
+        case "tool_call": {
+            if (message.status === "running") {
+                if (message.args !== undefined && message.truncated?.args !== true) {
+                    toolInputs.set(message.call_id, message.args);
+                }
+                return [];
+            }
+            const cachedInput = toolInputs.get(message.call_id);
+            const hasCachedInput = toolInputs.has(message.call_id);
+            toolInputs.delete(message.call_id);
+            if (message.truncated?.args === true && !hasCachedInput) {
+                return [
+                    {
+                        type: "failed",
+                        error: {
+                            kind: "agent-run-failed",
+                            detail: `Cursor truncated the input for tool call ${message.call_id}.`,
+                        },
+                    },
+                ];
+            }
+            if (message.truncated?.result === true) {
+                return [
+                    {
+                        type: "failed",
+                        error: {
+                            kind: "agent-run-failed",
+                            detail: `Cursor truncated the result for tool call ${message.call_id}.`,
+                        },
+                    },
+                ];
+            }
+            const input = message.truncated?.args === true || message.args === undefined ? cachedInput : message.args;
+            const tool = nativeTool(message.name, input);
+            const call = {
+                type: "tool-call",
+                id: message.call_id,
+                name: tool.name,
+                input: tool.input,
+            };
+            const result = cursorResult(message.result);
+            return [
+                call,
+                {
+                    type: "tool-result",
+                    id: message.call_id,
+                    name: tool.name,
+                    result: resultOutput(tool.name, result.value),
+                    isError: message.status === "error" || result.isError,
+                },
+            ];
+        }
+        case "usage":
+            return [
+                {
+                    type: "usage",
+                    input: message.usage.inputTokens ?? 0,
+                    output: message.usage.outputTokens ?? 0,
+                    cacheRead: message.usage.cacheReadTokens ?? 0,
+                    cacheWrite: message.usage.cacheWriteTokens ?? 0,
+                    reasoning: message.usage.reasoningTokens ?? 0,
+                    total: message.usage.totalTokens ?? 0,
+                },
+            ];
+        case "status":
+            return [];
+        case "system":
+        case "user":
+        case "request":
+        case "task":
+            return [];
+        default: {
+            const _exhaustive = message;
+            return _exhaustive;
+        }
+    }
+}
+function nativeTool(name, value) {
+    const input = jsonValue(value);
+    if (!isJsonObject(input))
+        return { name, input };
+    if (name === "read" || name === "edit" || name === "write") {
+        return { name, input: rename(input, "path", "filePath") };
+    }
+    if (name === "ls")
+        return { name: "list", input };
+    if (name === "glob") {
+        return { name, input: rename(rename(input, "globPattern", "pattern"), "targetDirectory", "path") };
+    }
+    if (name === "grep") {
+        let mapped = rename(input, "glob", "include");
+        mapped = rename(mapped, "headLimit", "limit");
+        if (typeof mapped.caseInsensitive === "boolean") {
+            mapped = { ...mapped, caseSensitive: !mapped.caseInsensitive };
+            delete mapped.caseInsensitive;
+        }
+        return { name, input: mapped };
+    }
+    if (name === "updateTodos")
+        return { name: "todowrite", input };
+    if (name === "task")
+        return { name, input: rename(input, "subagentType", "subagent_type") };
+    return { name, input };
+}
+function rename(input, from, to) {
+    if (!(from in input))
+        return input;
+    const result = { ...input, [to]: input[from] ?? null };
+    delete result[from];
+    return result;
+}
+function cursorResult(value) {
+    const result = jsonValue(value);
+    if (!isJsonObject(result) || typeof result.status !== "string")
+        return { value: result, isError: false };
+    const isError = result.status !== "success";
+    if ("value" in result)
+        return { value: result.value ?? null, isError };
+    if (isError && "error" in result)
+        return { value: result.error ?? "Tool call failed", isError: true };
+    return { value: result, isError };
+}
+function resultOutput(name, value) {
+    return textOutput(name, value);
+}
+function textOutput(name, value) {
+    if (typeof value === "string")
+        return value;
+    if (isJsonObject(value)) {
+        if (name === "shell") {
+            const stdout = typeof value.stdout === "string" ? value.stdout : "";
+            const stderr = typeof value.stderr === "string" ? value.stderr : "";
+            const text = stdout + stderr;
+            return text.length > 0 ? text : "(no output)";
+        }
+        if (name === "read" && typeof value.content === "string")
+            return value.content;
+        if (name === "edit" && typeof value.diffString === "string")
+            return value.diffString;
+        if (name === "glob" && Array.isArray(value.files))
+            return value.files.filter(isString).join("\n");
+        if (name === "task" && typeof value.resultSuffix === "string")
+            return value.resultSuffix;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function jsonValue(value, seen = new WeakSet()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value !== "object")
+        return value === undefined ? null : String(value);
+    if (seen.has(value))
+        return "[Circular]";
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.map((item) => jsonValue(item, seen));
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonValue(item, seen)]));
+}

package/dist/bridge/turn.d.ts

@@ -0,0 +1,29 @@
+import { type AgentModeOption, type ModelParameterValue } from "@cursor/sdk";
+import type { CursorLink } from "../auth/link.ts";
+import { type CursorModelDescriptor } from "../catalog/catalog.ts";
+import { type CatalogModelID } from "../ids.ts";
+import type { CursorAgentOptions } from "../model/provider-options.ts";
+import { openCursorAgent } from "./agent.ts";
+import { type BindingStore, type TurnScope } from "./binding.ts";
+import { type Conversation } from "./conversation.ts";
+import type { KeyedLock } from "./lock.ts";
+import { type TurnEvent } from "./translate.ts";
+export interface TurnRequest {
+    readonly modelID: CatalogModelID;
+    readonly scope: TurnScope | undefined;
+    readonly conversation: Conversation;
+    readonly params?: readonly ModelParameterValue[];
+    readonly mode?: AgentModeOption;
+    readonly agentOptions?: CursorAgentOptions;
+    readonly includeRawChunks?: boolean;
+    readonly signal?: AbortSignal;
+}
+export interface TurnRunnerContext {
+    readonly link: CursorLink;
+    readonly models: () => readonly CursorModelDescriptor[];
+    readonly bindings: BindingStore;
+    readonly clock: () => number;
+    readonly lock: KeyedLock;
+    readonly openAgent?: typeof openCursorAgent;
+}
+export declare function createTurnRunner(ctx: TurnRunnerContext): (request: TurnRequest) => AsyncIterable<TurnEvent>;