opencode-cursor-provider 0.1.0

package/dist/bridge/turn.js

@@ -0,0 +1,219 @@
+import { AuthenticationError, CursorAgentError, } from "@cursor/sdk";
+import { resolveWireId } from "../catalog/catalog.js";
+import { nowMs } from "../ids.js";
+import { isAgentLost, openCursorAgent } from "./agent.js";
+import { route } from "./binding.js";
+import { checkpointOf, cursorMessage, resumeTurn, } from "./conversation.js";
+import { createResponseJournal } from "./response-journal.js";
+import { createMessageTranslator } from "./translate.js";
+export function createTurnRunner(ctx) {
+    return (request) => runTurn(ctx, request);
+}
+async function* runTurn(ctx, request) {
+    const lockKey = request.scope?.sessionID ?? "one-shot";
+    const release = await ctx.lock.acquire(lockKey);
+    try {
+        const apiKey = await ctx.link.resolve();
+        if (apiKey === undefined) {
+            yield { type: "failed", error: { kind: "not-linked" } };
+            return;
+        }
+        const wireID = resolveWireId(ctx.models(), request.modelID);
+        if (wireID === undefined) {
+            yield { type: "failed", error: { kind: "model-unknown", modelID: request.modelID } };
+            return;
+        }
+        let plan = planTurn(request, apiKey, wireID, ctx.bindings);
+        if (typeof plan.prompt === "string" && plan.prompt.trim().length === 0) {
+            yield { type: "done", reason: "stop" };
+            return;
+        }
+        let retryLost = true;
+        while (true) {
+            let session;
+            let emitted = false;
+            try {
+                if (request.signal?.aborted) {
+                    yield { type: "failed", error: { kind: "cancelled" } };
+                    return;
+                }
+                session = await (ctx.openAgent ?? openCursorAgent)({
+                    apiKey: plan.apiKey,
+                    wireID: plan.wireID,
+                    params: plan.params,
+                    cwd: request.scope?.cwd ?? process.cwd(),
+                    resume: plan.kind === "RESUME" ? plan.binding?.agentID : undefined,
+                    agentOptions: request.agentOptions,
+                });
+                if (request.signal?.aborted) {
+                    yield { type: "failed", error: { kind: "cancelled" } };
+                    return;
+                }
+                const run = await session.send(plan.prompt, request.mode === undefined ? undefined : { mode: request.mode });
+                emitted = true;
+                yield {
+                    type: "response-metadata",
+                    id: run.id,
+                    ...(run.createdAt === undefined ? {} : { timestamp: run.createdAt }),
+                    modelId: run.model?.id ?? plan.wireID,
+                };
+                let cancelPromise;
+                const cancel = () => {
+                    if (cancelPromise !== undefined || !run.supports("cancel"))
+                        return;
+                    cancelPromise = run.cancel().catch(() => { });
+                };
+                request.signal?.addEventListener("abort", cancel);
+                if (request.signal?.aborted)
+                    cancel();
+                let sawUsage = false;
+                const response = createResponseJournal();
+                const translate = createMessageTranslator();
+                try {
+                    for await (const message of run.stream()) {
+                        if (request.signal?.aborted) {
+                            yield { type: "failed", error: { kind: "cancelled" } };
+                            return;
+                        }
+                        if (request.includeRawChunks === true)
+                            yield { type: "raw", value: message };
+                        for (const candidate of translate(message)) {
+                            const event = response.accept(candidate);
+                            if (event === undefined)
+                                continue;
+                            if (event.type === "usage")
+                                sawUsage = true;
+                            yield event;
+                        }
+                    }
+                    if (request.signal?.aborted) {
+                        yield { type: "failed", error: { kind: "cancelled" } };
+                        return;
+                    }
+                    const result = await run.wait();
+                    if (result.status === "cancelled") {
+                        yield { type: "failed", error: { kind: "cancelled" } };
+                        return;
+                    }
+                    if (!sawUsage && result.usage !== undefined)
+                        yield usageEvent(result.usage);
+                    if (result.status === "error") {
+                        yield {
+                            type: "failed",
+                            error: { kind: "agent-run-failed", detail: result.error?.message ?? result.id },
+                        };
+                        return;
+                    }
+                    if (request.scope && plan.kind !== "ONE_SHOT") {
+                        ctx.bindings.put({
+                            sessionID: request.scope.sessionID,
+                            agentID: session.id,
+                            modelID: request.modelID,
+                            cwd: request.scope.cwd,
+                            checkpoint: checkpointOf(withResponse(request.conversation, response.parts())),
+                            params: request.params,
+                            mode: request.mode,
+                            agentOptions: request.agentOptions,
+                            lastUsedAt: nowMs(ctx.clock),
+                        });
+                    }
+                    yield {
+                        type: "done",
+                        reason: "stop",
+                        metadata: {
+                            runId: result.id,
+                            ...(result.requestId === undefined ? {} : { requestId: result.requestId }),
+                            ...(result.durationMs === undefined ? {} : { durationMs: result.durationMs }),
+                            ...(result.model === undefined ? {} : { modelId: result.model.id }),
+                        },
+                    };
+                    return;
+                }
+                finally {
+                    request.signal?.removeEventListener("abort", cancel);
+                    await cancelPromise;
+                }
+            }
+            catch (error) {
+                if (retryLost && !emitted && plan.kind === "RESUME" && request.scope && isAgentLost(error)) {
+                    retryLost = false;
+                    ctx.bindings.drop(request.scope.sessionID);
+                    plan = {
+                        ...plan,
+                        kind: "FRESH",
+                        binding: undefined,
+                        prompt: promptFor("FRESH", request.conversation, undefined),
+                    };
+                    continue;
+                }
+                yield failedFromCaught(error, request.signal, ctx.link.reject);
+                return;
+            }
+            finally {
+                await session?.dispose();
+            }
+        }
+    }
+    finally {
+        release();
+    }
+}
+function withResponse(conversation, parts) {
+    if (parts.length === 0)
+        return conversation;
+    return { ...conversation, turns: [...conversation.turns, { role: "assistant", parts }] };
+}
+function planTurn(request, apiKey, wireID, bindings) {
+    const binding = request.scope ? bindings.get(request.scope.sessionID) : undefined;
+    const kind = route({
+        scope: request.scope,
+        binding,
+        modelID: request.modelID,
+        conversation: request.conversation,
+        params: request.params,
+        mode: request.mode,
+        agentOptions: request.agentOptions,
+    });
+    return {
+        apiKey,
+        wireID,
+        params: request.params,
+        kind,
+        binding,
+        prompt: promptFor(kind, request.conversation, binding),
+    };
+}
+function usageEvent(usage) {
+    return {
+        type: "usage",
+        input: usage.inputTokens,
+        output: usage.outputTokens,
+        cacheRead: usage.cacheReadTokens,
+        cacheWrite: usage.cacheWriteTokens,
+        reasoning: usage.reasoningTokens ?? 0,
+        total: usage.totalTokens,
+    };
+}
+function promptFor(kind, conversation, binding) {
+    if (kind === "RESUME" && binding) {
+        const turn = resumeTurn(conversation, binding.checkpoint);
+        if (turn !== undefined)
+            return cursorMessage([], [turn]);
+    }
+    return cursorMessage(conversation.system, conversation.turns);
+}
+function failedFromCaught(error, signal, unlink) {
+    if (signal?.aborted)
+        return { type: "failed", error: { kind: "cancelled" } };
+    if (error instanceof AuthenticationError) {
+        unlink();
+        return { type: "failed", error: { kind: "not-linked" } };
+    }
+    if (error instanceof CursorAgentError) {
+        return { type: "failed", error: { kind: "agent-start-failed", detail: error.message } };
+    }
+    return {
+        type: "failed",
+        error: { kind: "agent-start-failed", detail: error instanceof Error ? error.message : "unknown error" },
+    };
+}

package/dist/catalog/catalog.d.ts

@@ -0,0 +1,20 @@
+import type { ModelParameterDefinition, ModelParameterValue, ModelVariant } from "@cursor/sdk";
+import { Model } from "@opencode-ai/plugin";
+import type { CatalogEditor } from "@opencode-ai/plugin/promise/catalog";
+import { type CatalogModelID, type CursorModelID } from "../ids.ts";
+export interface CursorModelDescriptor {
+    readonly catalogID: CatalogModelID;
+    readonly wireID: CursorModelID;
+    readonly name: string;
+    readonly parameters: readonly ModelParameterDefinition[];
+    readonly variants: readonly ModelVariant[];
+}
+export declare const CURSOR_MODEL_PARAMS = "cursorModelParams";
+export declare const SEED_MODELS: readonly CursorModelDescriptor[];
+export declare function providerId(): string & import("effect/Brand").Brand<"Provider.ID">;
+export declare function applyProvider(draft: CatalogEditor): void;
+export declare function applyModels(draft: CatalogEditor, models: readonly CursorModelDescriptor[]): void;
+export declare function parseListedModels(raw: unknown): CursorModelDescriptor[];
+export declare function toCatalogVariants(model: CursorModelDescriptor | undefined): Model.Variant[];
+export declare function modelParamsFromOptions(options: unknown): readonly ModelParameterValue[] | undefined;
+export declare function resolveWireId(models: readonly CursorModelDescriptor[], catalogID: string): CursorModelID | undefined;

package/dist/catalog/catalog.js

@@ -0,0 +1,192 @@
+import { Integration, Model, Provider } from "@opencode-ai/plugin";
+import { PACKAGE_SPEC, PROVIDER_ID, asCatalogModelID, asCursorModelID } from "../ids.js";
+export const CURSOR_MODEL_PARAMS = "cursorModelParams";
+export const SEED_MODELS = [
+    {
+        catalogID: asCatalogModelID("composer-2.5"),
+        wireID: asCursorModelID("composer-2.5"),
+        name: "Composer 2.5",
+        parameters: [],
+        variants: [],
+    },
+    {
+        catalogID: asCatalogModelID("auto"),
+        wireID: asCursorModelID("auto"),
+        name: "Cursor Auto",
+        parameters: [],
+        variants: [],
+    },
+];
+export function providerId() {
+    return Provider.ID.make(PROVIDER_ID);
+}
+export function applyProvider(draft) {
+    draft.provider.update(PROVIDER_ID, (provider) => {
+        provider.id = providerId();
+        provider.name = "Cursor";
+        provider.package = PACKAGE_SPEC;
+        provider.integrationID = Integration.ID.make(PROVIDER_ID);
+        provider.activation = "auto";
+        dropBaseURL(provider.settings);
+    });
+}
+export function applyModels(draft, models) {
+    for (const model of models) {
+        writeModel(draft, model.catalogID, model);
+    }
+    const preferred = models[0];
+    if (preferred) {
+        writeModel(draft, "default", preferred);
+        draft.model.default.set(PROVIDER_ID, preferred.catalogID);
+    }
+}
+function writeModel(draft, catalogID, model) {
+    draft.model.update(PROVIDER_ID, catalogID, (entry) => {
+        const defaults = Model.Info.default(providerId(), Model.ID.make(catalogID));
+        entry.id = defaults.id;
+        entry.modelID = Model.ID.make(model.wireID);
+        entry.providerID = defaults.providerID;
+        entry.name = model.name;
+        entry.capabilities = { tools: false, input: ["text", "image"], output: ["text"] };
+        entry.variants = toCatalogVariants(model);
+        entry.time = defaults.time;
+        entry.cost = defaults.cost;
+        entry.status = "active";
+        entry.enabled = true;
+        entry.limit = defaults.limit;
+        entry.package = PACKAGE_SPEC;
+        dropBaseURL(entry.settings);
+    });
+}
+export function parseListedModels(raw) {
+    const listed = [];
+    const seen = new Set();
+    for (const item of listedItems(raw)) {
+        const parsed = parseListedItem(item);
+        if (parsed === undefined)
+            continue;
+        if (seen.has(parsed.catalogID))
+            continue;
+        seen.add(parsed.catalogID);
+        listed.push(parsed);
+    }
+    if (listed.length === 0)
+        return [...SEED_MODELS];
+    for (const seed of SEED_MODELS) {
+        if (!seen.has(seed.catalogID))
+            listed.push(seed);
+    }
+    return listed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function listedItems(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (isRecord(raw) && Array.isArray(raw.items))
+        return raw.items;
+    return [];
+}
+function parseListedItem(item) {
+    if (!isRecord(item))
+        return undefined;
+    const nested = isRecord(item.model) ? item.model : undefined;
+    const rawId = typeof item.id === "string" ? item.id : typeof nested?.id === "string" ? nested.id : undefined;
+    if (rawId === undefined)
+        return undefined;
+    const id = rawId.trim();
+    if (id.length === 0)
+        return undefined;
+    const rawName = typeof item.displayName === "string" ? item.displayName : undefined;
+    const name = rawName && rawName.length > 0 ? rawName : id;
+    return {
+        catalogID: asCatalogModelID(id),
+        wireID: asCursorModelID(id),
+        name,
+        parameters: parseParameters(item.parameters),
+        variants: parseVariants(item.variants),
+    };
+}
+function parseParameters(value) {
+    if (!Array.isArray(value))
+        return [];
+    const definitions = [];
+    for (const item of value) {
+        if (!isRecord(item) || typeof item.id !== "string" || !Array.isArray(item.values))
+            continue;
+        const values = [];
+        for (const candidate of item.values) {
+            if (!isRecord(candidate) || typeof candidate.value !== "string")
+                continue;
+            values.push({
+                value: candidate.value,
+                ...(typeof candidate.displayName === "string" ? { displayName: candidate.displayName } : {}),
+            });
+        }
+        definitions.push({
+            id: item.id,
+            values,
+            ...(typeof item.displayName === "string" ? { displayName: item.displayName } : {}),
+        });
+    }
+    return definitions;
+}
+function parseVariants(value) {
+    if (!Array.isArray(value))
+        return [];
+    const variants = [];
+    for (const item of value) {
+        if (!isRecord(item) || typeof item.displayName !== "string")
+            continue;
+        const params = parseParams(item.params);
+        if (params === undefined)
+            continue;
+        variants.push({
+            displayName: item.displayName,
+            params,
+            ...(typeof item.description === "string" ? { description: item.description } : {}),
+            ...(typeof item.isDefault === "boolean" ? { isDefault: item.isDefault } : {}),
+        });
+    }
+    return variants;
+}
+function parseParams(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const params = [];
+    for (const item of value) {
+        if (!isRecord(item) || typeof item.id !== "string" || typeof item.value !== "string")
+            return undefined;
+        params.push({ id: item.id, value: item.value });
+    }
+    return params;
+}
+export function toCatalogVariants(model) {
+    if (model === undefined)
+        return [];
+    const seen = new Map();
+    return model.variants.map((variant) => {
+        const count = (seen.get(variant.displayName) ?? 0) + 1;
+        seen.set(variant.displayName, count);
+        const id = count === 1 ? variant.displayName : `${variant.displayName}-${count}`;
+        return {
+            id: Model.VariantID.make(id),
+            body: { [CURSOR_MODEL_PARAMS]: variant.params.map((param) => ({ ...param })) },
+        };
+    });
+}
+export function modelParamsFromOptions(options) {
+    if (!isRecord(options))
+        return undefined;
+    return parseParams(options[CURSOR_MODEL_PARAMS]);
+}
+function dropBaseURL(settings) {
+    if (settings === undefined)
+        return;
+    delete settings.baseURL;
+}
+export function resolveWireId(models, catalogID) {
+    const match = models.find((model) => model.catalogID === catalogID);
+    return match?.wireID;
+}

package/dist/catalog/source.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import type { CursorLink } from "../auth/link.ts";
+import { type CursorModelDescriptor } from "./catalog.ts";
+export interface ModelSource {
+    list(): readonly CursorModelDescriptor[];
+    refresh(ctx: Plugin.Context): Promise<void>;
+}
+export declare function createModelSource(link: CursorLink): ModelSource;

package/dist/catalog/source.js

@@ -0,0 +1,30 @@
+import { AuthenticationError, Cursor } from "@cursor/sdk";
+import { parseListedModels, SEED_MODELS } from "./catalog.js";
+export function createModelSource(link) {
+    let models = [...SEED_MODELS];
+    return {
+        list() {
+            return models;
+        },
+        async refresh(ctx) {
+            await link.restore(ctx);
+            const apiKey = await link.resolve();
+            if (apiKey === undefined)
+                return;
+            try {
+                models = parseListedModels(await Cursor.models.list({ apiKey }));
+            }
+            catch (error) {
+                if (error instanceof AuthenticationError)
+                    link.reject();
+                return;
+            }
+            try {
+                await ctx.catalog.reload();
+            }
+            catch {
+                // Keep the listed models. The next credential or poll can replay the catalog.
+            }
+        },
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,35 @@
+import type { CursorAgentID, EpochMs } from "./ids.ts";
+export type UnsupportedReason = "tools-requested" | "tool-choice" | "structured-output" | "multiple-completions" | "file-input" | "tool-result-content" | "provider-option";
+export type CursorPluginError = {
+    readonly kind: "not-linked";
+} | {
+    readonly kind: "credential-expired";
+    readonly expiredAt: EpochMs;
+} | {
+    readonly kind: "login-cancelled";
+} | {
+    readonly kind: "login-failed";
+    readonly detail: string;
+} | {
+    readonly kind: "unsupported-request";
+    readonly reason: UnsupportedReason;
+} | {
+    readonly kind: "agent-start-failed";
+    readonly detail: string;
+} | {
+    readonly kind: "agent-run-failed";
+    readonly detail: string;
+} | {
+    readonly kind: "agent-lost";
+    readonly agentID: CursorAgentID;
+} | {
+    readonly kind: "model-unknown";
+    readonly modelID: string;
+} | {
+    readonly kind: "cancelled";
+};
+export declare class CursorPluginFailure extends Error {
+    readonly cause: CursorPluginError;
+    constructor(cause: CursorPluginError);
+    static message(cause: CursorPluginError): string;
+}

package/dist/errors.js

@@ -0,0 +1,36 @@
+export class CursorPluginFailure extends Error {
+    cause;
+    constructor(cause) {
+        super(CursorPluginFailure.message(cause));
+        this.name = "CursorPluginFailure";
+        this.cause = cause;
+    }
+    static message(cause) {
+        switch (cause.kind) {
+            case "not-linked":
+                return "Cursor is not connected. Run /connect and choose Cursor.";
+            case "credential-expired":
+                return "The Cursor login has expired. Run /connect again.";
+            case "login-cancelled":
+                return "Cursor sign-in was cancelled.";
+            case "login-failed":
+                return `Cursor sign-in failed: ${cause.detail}`;
+            case "unsupported-request":
+                return `Cursor cannot honor this request (${cause.reason}).`;
+            case "agent-start-failed":
+                return `Cursor did not start: ${cause.detail}`;
+            case "agent-run-failed":
+                return `Cursor failed mid-run: ${cause.detail}`;
+            case "agent-lost":
+                return `The Cursor agent ${cause.agentID} is gone. Starting a new one.`;
+            case "model-unknown":
+                return `Unknown Cursor model: ${cause.modelID}`;
+            case "cancelled":
+                return "The Cursor run was cancelled.";
+            default: {
+                const _exhaustive = cause;
+                return _exhaustive;
+            }
+        }
+    }
+}

package/dist/ids.d.ts

@@ -0,0 +1,33 @@
+export type Brand<T, B extends string> = T & {
+    readonly __brand: B;
+};
+export type CursorApiKey = Brand<string, "CursorApiKey">;
+export type CursorAgentID = Brand<string, "CursorAgentID">;
+export type CursorModelID = Brand<string, "CursorModelID">;
+export type CatalogModelID = Brand<string, "CatalogModelID">;
+export type OpencodeSessionID = Brand<string, "OpencodeSessionID">;
+export type EpochMs = Brand<number, "EpochMs">;
+export declare const PROVIDER_ID = "cursor";
+export declare const INTEGRATION_ID = "cursor";
+export declare const OAUTH_METHOD_ID = "oauth";
+export declare const PACKAGE_SPEC = "aisdk:@ai-sdk/openai-compatible";
+export declare const ENV_NAME = "CURSOR_API_KEY";
+export type Parsed<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly issue: string;
+};
+export declare function ok<T>(value: T): Parsed<T>;
+export declare function fail<T>(issue: string): Parsed<T>;
+export declare function asApiKey(value: string): CursorApiKey;
+export declare function asAgentID(value: string): CursorAgentID;
+export declare function asCatalogModelID(value: string): CatalogModelID;
+export declare function asCursorModelID(value: string): CursorModelID;
+export declare function asSessionID(value: string): OpencodeSessionID;
+export declare function asEpochMs(value: number): EpochMs;
+export declare function parseNonEmpty(value: unknown, label: string): Parsed<string>;
+export declare function parseApiKey(value: unknown): Parsed<CursorApiKey>;
+export declare function parseAgentID(value: unknown): Parsed<CursorAgentID>;
+export declare function nowMs(clock?: () => number): EpochMs;

package/dist/ids.js

@@ -0,0 +1,52 @@
+export const PROVIDER_ID = "cursor";
+export const INTEGRATION_ID = "cursor";
+export const OAUTH_METHOD_ID = "oauth";
+export const PACKAGE_SPEC = "aisdk:@ai-sdk/openai-compatible";
+export const ENV_NAME = "CURSOR_API_KEY";
+export function ok(value) {
+    return { ok: true, value };
+}
+export function fail(issue) {
+    return { ok: false, issue };
+}
+export function asApiKey(value) {
+    return value;
+}
+export function asAgentID(value) {
+    return value;
+}
+export function asCatalogModelID(value) {
+    return value;
+}
+export function asCursorModelID(value) {
+    return value;
+}
+export function asSessionID(value) {
+    return value;
+}
+export function asEpochMs(value) {
+    return value;
+}
+export function parseNonEmpty(value, label) {
+    if (typeof value !== "string")
+        return fail(`${label} must be a string`);
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return fail(`${label} must not be empty`);
+    return ok(trimmed);
+}
+export function parseApiKey(value) {
+    const parsed = parseNonEmpty(value, "api key");
+    if (!parsed.ok)
+        return parsed;
+    return ok(asApiKey(parsed.value));
+}
+export function parseAgentID(value) {
+    const parsed = parseNonEmpty(value, "agent id");
+    if (!parsed.ok)
+        return parsed;
+    return ok(asAgentID(parsed.value));
+}
+export function nowMs(clock = Date.now) {
+    return asEpochMs(clock());
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { plugin } from "./plugin.ts";
+export { model } from "./runtime.ts";
+export type { CursorProviderOptions } from "./model/provider-options.ts";
+export default plugin;

package/dist/index.js

@@ -0,0 +1,3 @@
+import { plugin } from "./plugin.js";
+export { model } from "./runtime.js";
+export default plugin;

package/dist/model/language-model.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { ModelParameterValue } from "@cursor/sdk";
+import type { SessionAgentBridge } from "../bridge/bridge.ts";
+import type { CatalogModelID } from "../ids.ts";
+export declare function toLanguageModel(input: {
+    bridge: SessionAgentBridge;
+    modelID: CatalogModelID;
+    wireID: string;
+    params?: readonly ModelParameterValue[];
+}): LanguageModelV3;