opencode-ext-connector 0.3.0

package/dist/providers/cursor/server-dispatch.js

@@ -0,0 +1,178 @@
+import { parseCursorWireBlobId } from "./blob-store";
+import { cursorMcpDefinitions, encodeCursorClientFrame, encodeNativeRejectFrame, encodeRequestContextFrame, } from "./exec-reply";
+import { buildCursorInteractionReply } from "./interaction-reply";
+import { encodeConversationCheckpoint } from "./proto/checkpoint";
+import { decodeAgentServerMessage } from "./proto/server";
+function result(outcome, replyFrames = []) {
+    return { outcome, replyFrames, closeStream: false };
+}
+function checkpointBlobIds(checkpoint) {
+    return [
+        ...checkpoint.rootPromptMessageBlobIds,
+        ...checkpoint.legacyTurnBlobIds,
+        ...checkpoint.todoBlobIds,
+        ...checkpoint.turnBlobIds,
+        ...checkpoint.summaryArchiveBlobIds,
+    ];
+}
+export function createCursorServerDispatcher(options) {
+    const parkedCalls = new Map();
+    const dispatchUpdate = (update) => {
+        switch (update.kind) {
+            case "text-delta":
+                return result({ kind: "text", text: update.text });
+            case "thinking-delta":
+                return result({ kind: "thinking", text: update.text });
+            case "token-delta":
+                return result({ kind: "tokens", tokens: update.tokens });
+            case "turn-ended":
+                return result({ kind: "turn-ended" });
+            case "heartbeat":
+                return result({ kind: "heartbeat" });
+            case "tool-call-started":
+            case "tool-call-completed":
+            case "thinking-completed":
+            case "user-message-appended":
+            case "partial-tool-call":
+            case "summary":
+            case "summary-started":
+            case "summary-completed":
+            case "shell-output-delta":
+            case "tool-call-delta":
+            case "step-started":
+            case "step-completed":
+            case "field-25":
+                return result({ kind: "telemetry", name: update.kind });
+            default:
+                return update;
+        }
+    };
+    const dispatchKv = (message) => {
+        const blobId = parseCursorWireBlobId(message.blobId);
+        switch (message.kind) {
+            case "get-blob": {
+                const blobData = options.blobStore.get(blobId);
+                const reply = encodeCursorClientFrame({
+                    kind: "kv-client-message",
+                    message: {
+                        kind: "get-blob-result",
+                        id: message.id,
+                        ...(blobData === null ? {} : { blobData }),
+                    },
+                });
+                return result({ kind: "kv-get", id: message.id, found: blobData !== null }, [reply]);
+            }
+            case "set-blob": {
+                const matches = options.blobStore.hash(message.blobData) === blobId;
+                const stored = matches && options.blobStore.putVerified(blobId, message.blobData) !== null;
+                const reply = encodeCursorClientFrame({
+                    kind: "kv-client-message",
+                    message: {
+                        kind: "set-blob-result",
+                        id: message.id,
+                        ...(stored ? {} : { error: matches ? "blob-store-full" : "blob-id-mismatch" }),
+                    },
+                });
+                return result({ kind: "kv-set", id: message.id, stored }, [reply]);
+            }
+            default:
+                return message;
+        }
+    };
+    const dispatchExec = (message) => {
+        switch (message.kind) {
+            case "metadata":
+                return result({ kind: "telemetry", name: message.kind });
+            case "request-context-args":
+                return result({ kind: "request-context-replied", id: message.id, execId: message.execId }, [
+                    encodeRequestContextFrame(message, options.tools),
+                ]);
+            case "mcp-args": {
+                const callId = message.args.toolCallId;
+                const toolNames = new Set(cursorMcpDefinitions(options.tools).flatMap((tool) => [tool.name, tool.toolName]));
+                if (callId === "" || parkedCalls.has(callId)) {
+                    return result({
+                        kind: "drift",
+                        area: "mcp-call",
+                        detail: callId === "" ? "missing-call-id" : "duplicate-call-id",
+                        stranding: true,
+                    });
+                }
+                const requestedName = message.args.toolName || message.args.name;
+                if (!toolNames.has(requestedName)) {
+                    const reply = encodeCursorClientFrame({
+                        kind: "exec-client-message",
+                        message: {
+                            kind: "mcp-result",
+                            id: message.id,
+                            execId: message.execId,
+                            result: {
+                                kind: "tool-not-found",
+                                name: requestedName,
+                                availableTools: [...toolNames],
+                            },
+                        },
+                    });
+                    return result({ kind: "mcp-rejected", callId }, [reply]);
+                }
+                const parked = {
+                    callId,
+                    execId: message.execId,
+                    execMessageId: message.id,
+                    args: message.args,
+                };
+                parkedCalls.set(callId, parked);
+                return result({ kind: "mcp-parked", parked });
+            }
+            case "native":
+                return result({ kind: "native-rejected", operation: message.operation }, [
+                    encodeNativeRejectFrame(message),
+                ]);
+            default:
+                return message;
+        }
+    };
+    const dispatch = (message) => {
+        switch (message.kind) {
+            case "interaction-update":
+                return dispatchUpdate(message.update);
+            case "kv-server-message":
+                return dispatchKv(message.message);
+            case "exec-server-message":
+                return dispatchExec(message.message);
+            case "conversation-checkpoint-update": {
+                const blobIds = checkpointBlobIds(message.checkpoint).map(parseCursorWireBlobId);
+                const stored = options.checkpointStore.update({
+                    sessionId: options.sessionId,
+                    bytes: encodeConversationCheckpoint(message.checkpoint),
+                    blobIds,
+                });
+                return result({ kind: "checkpoint", stored });
+            }
+            case "interaction-query": {
+                const interactionReply = buildCursorInteractionReply(message.query);
+                const reply = encodeCursorClientFrame({
+                    kind: "interaction-response",
+                    response: interactionReply.response,
+                });
+                return result({ kind: "interaction-replied", id: message.query.id, action: interactionReply.action }, [reply]);
+            }
+            case "exec-server-control":
+                return result({ kind: "control", control: message.control.kind, id: message.control.id });
+            case "unknown-oneof":
+                return result({
+                    kind: "drift",
+                    area: "server-message",
+                    detail: `field-${message.field}`,
+                    stranding: message.drift.stranding,
+                });
+            default:
+                return message;
+        }
+    };
+    return {
+        dispatch,
+        dispatchBytes: (bytes) => dispatch(decodeAgentServerMessage(bytes)),
+        parkedCalls,
+    };
+}

package/dist/providers/cursor/session-state.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { Clock } from "../../core/clock";
+import { type CursorBlobId, type CursorBlobStore } from "./blob-store";
+export declare const CursorSessionIdSchema: z.core.$ZodBranded<z.ZodString, "CursorSessionId">;
+export type CursorSessionId = z.output<typeof CursorSessionIdSchema>;
+export type CursorSessionStateStoreOptions = {
+    readonly blobStore: CursorBlobStore;
+    readonly clock: Clock;
+    readonly maxKeysPerSession: number;
+    readonly maxSessions: number;
+    /** Logical milliseconds; zero expires sessions on the next store operation. */
+    readonly ttlMs: number;
+};
+export type CursorSessionStateStore = {
+    readonly get: (sessionId: CursorSessionId, key: string) => Uint8Array | null;
+    readonly invalidate: (sessionId: CursorSessionId) => void;
+    readonly set: (sessionId: CursorSessionId, key: string, value: Uint8Array) => CursorBlobId | null;
+    readonly size: () => number;
+};
+export declare function parseCursorSessionId(input: unknown): CursorSessionId;
+export declare function createCursorSessionStateStore(options: CursorSessionStateStoreOptions): CursorSessionStateStore;

package/dist/providers/cursor/session-state.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { requireCursorStoreTtl, requirePositiveCursorStoreBound, } from "./blob-store";
+export const CursorSessionIdSchema = z
+    .string()
+    .min(1)
+    .max(256)
+    .refine((value) => value.trim() === value)
+    .refine((value) => [...value].every((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 32 && codePoint !== 127;
+}))
+    .brand();
+export function parseCursorSessionId(input) {
+    return CursorSessionIdSchema.parse(input);
+}
+export function createCursorSessionStateStore(options) {
+    requirePositiveCursorStoreBound(options.maxKeysPerSession, "maxKeysPerSession");
+    requirePositiveCursorStoreBound(options.maxSessions, "maxSessions");
+    requireCursorStoreTtl(options.ttlMs);
+    const sessions = new Map();
+    const remove = (sessionId) => {
+        const entry = sessions.get(sessionId);
+        if (entry !== undefined) {
+            sessions.delete(sessionId);
+            for (const blobId of entry.values.values()) {
+                options.blobStore.release(blobId);
+            }
+        }
+    };
+    const evictExpired = (nowMs) => {
+        for (const [sessionId, entry] of sessions) {
+            if (nowMs - entry.lastAccessMs >= options.ttlMs) {
+                remove(sessionId);
+            }
+        }
+    };
+    const evictToBounds = () => {
+        while (sessions.size > options.maxSessions) {
+            const oldest = sessions.keys().next().value;
+            if (oldest === undefined) {
+                return;
+            }
+            remove(oldest);
+        }
+    };
+    const touch = (sessionId, entry, nowMs) => {
+        const updated = { values: entry.values, lastAccessMs: nowMs };
+        sessions.delete(sessionId);
+        sessions.set(sessionId, updated);
+        return updated;
+    };
+    const invalidate = remove;
+    return {
+        get: (sessionId, key) => {
+            const nowMs = options.clock.nowMs();
+            evictExpired(nowMs);
+            const entry = sessions.get(sessionId);
+            const blobId = entry?.values.get(key);
+            if (entry === undefined || blobId === undefined) {
+                return null;
+            }
+            const value = options.blobStore.get(blobId);
+            if (value === null) {
+                entry.values.delete(key);
+                options.blobStore.release(blobId);
+                if (entry.values.size === 0) {
+                    invalidate(sessionId);
+                }
+                return null;
+            }
+            entry.values.delete(key);
+            entry.values.set(key, blobId);
+            touch(sessionId, entry, nowMs);
+            return value;
+        },
+        invalidate,
+        set: (sessionId, key, value) => {
+            const blobId = options.blobStore.put(value);
+            if (blobId === null || !options.blobStore.pin(blobId)) {
+                return null;
+            }
+            const nowMs = options.clock.nowMs();
+            evictExpired(nowMs);
+            const existing = sessions.get(sessionId);
+            const entry = existing === undefined
+                ? { values: new Map(), lastAccessMs: nowMs }
+                : touch(sessionId, existing, nowMs);
+            const replaced = entry.values.get(key);
+            entry.values.delete(key);
+            entry.values.set(key, blobId);
+            if (replaced !== undefined) {
+                options.blobStore.release(replaced);
+            }
+            while (entry.values.size > options.maxKeysPerSession) {
+                const oldestKey = entry.values.keys().next().value;
+                if (oldestKey === undefined) {
+                    break;
+                }
+                const evicted = entry.values.get(oldestKey);
+                entry.values.delete(oldestKey);
+                if (evicted !== undefined) {
+                    options.blobStore.release(evicted);
+                }
+            }
+            sessions.set(sessionId, entry);
+            evictToBounds();
+            if (!sessions.has(sessionId)) {
+                options.blobStore.release(blobId);
+                return null;
+            }
+            return blobId;
+        },
+        size: () => {
+            evictExpired(options.clock.nowMs());
+            return sessions.size;
+        },
+    };
+}

package/dist/providers/cursor/session.d.ts

@@ -0,0 +1 @@
+export declare function extractCursorSessionId(line: string): string | null;

package/dist/providers/cursor/session.js

@@ -0,0 +1,26 @@
+function stringField(value, key) {
+    if (!(key in value)) {
+        return null;
+    }
+    const field = Reflect.get(value, key);
+    return typeof field === "string" && field.length > 0 ? field : null;
+}
+export function extractCursorSessionId(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return null;
+    }
+    return (stringField(parsed, "session_id") ??
+        stringField(parsed, "chatId") ??
+        stringField(parsed, "resumeId"));
+}

package/dist/providers/cursor/settle-cleanup.d.ts

@@ -0,0 +1 @@
+export declare function settleCursorCleanup(obligations: readonly (() => void | Promise<void>)[]): Promise<void>;

package/dist/providers/cursor/settle-cleanup.js

@@ -0,0 +1,11 @@
+export async function settleCursorCleanup(obligations) {
+    const failures = [];
+    for (const obligation of obligations) {
+        const [result] = await Promise.allSettled([Promise.resolve().then(obligation)]);
+        if (result?.status === "rejected")
+            failures.push(result.reason);
+    }
+    if (failures.length > 0) {
+        throw new AggregateError(failures, "Cursor cleanup failed");
+    }
+}

package/dist/providers/cursor/stream-adapter.d.ts

@@ -0,0 +1,17 @@
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+import type { CursorReplayState } from "./recovery";
+import type { CursorDispatchOutcome } from "./server-dispatch";
+type EmittableOutcome = Extract<CursorDispatchOutcome, {
+    readonly kind: "text" | "thinking" | "mcp-parked";
+}>;
+export type CursorStreamAdapter = {
+    readonly stream: ReadableStream<LanguageModelV3StreamPart>;
+    readonly emit: (outcome: EmittableOutcome) => void;
+    readonly noteCheckpoint: () => void;
+    readonly replayState: () => CursorReplayState;
+    readonly suspendForRetry: () => void;
+    readonly finish: (reason: "stop" | "tool-calls") => void;
+    readonly fail: (error: unknown) => void;
+};
+export declare function createCursorStreamAdapter(): CursorStreamAdapter;
+export {};

package/dist/providers/cursor/stream-adapter.js

@@ -0,0 +1,99 @@
+import { emptyCursorUsage } from "./usage";
+export function createCursorStreamAdapter() {
+    let streamController = null;
+    let outputEpoch = 0;
+    let checkpointEpoch = null;
+    let toolBoundary = false;
+    let section = 1;
+    let textStarted = false;
+    let reasoningStarted = false;
+    let settled = false;
+    const stream = new ReadableStream({
+        start(controller) {
+            streamController = controller;
+            controller.enqueue({ type: "stream-start", warnings: [] });
+        },
+    });
+    const controller = () => {
+        if (streamController === null)
+            throw new TypeError("Cursor stream adapter is not initialized");
+        return streamController;
+    };
+    const closeSections = () => {
+        if (reasoningStarted) {
+            controller().enqueue({ type: "reasoning-end", id: `reasoning-${section}` });
+            reasoningStarted = false;
+        }
+        if (textStarted) {
+            controller().enqueue({ type: "text-end", id: `text-${section}` });
+            textStarted = false;
+        }
+    };
+    const emit = (outcome) => {
+        if (settled)
+            return;
+        switch (outcome.kind) {
+            case "text":
+                if (!textStarted)
+                    controller().enqueue({ type: "text-start", id: `text-${section}` });
+                textStarted = true;
+                outputEpoch += 1;
+                controller().enqueue({ type: "text-delta", id: `text-${section}`, delta: outcome.text });
+                return;
+            case "thinking":
+                if (!reasoningStarted) {
+                    controller().enqueue({ type: "reasoning-start", id: `reasoning-${section}` });
+                }
+                reasoningStarted = true;
+                outputEpoch += 1;
+                controller().enqueue({
+                    type: "reasoning-delta",
+                    id: `reasoning-${section}`,
+                    delta: outcome.text,
+                });
+                return;
+            case "mcp-parked":
+                toolBoundary = true;
+                controller().enqueue({
+                    type: "tool-call",
+                    toolCallId: outcome.parked.args.toolCallId,
+                    toolName: outcome.parked.args.toolName || outcome.parked.args.name,
+                    input: JSON.stringify(outcome.parked.args.args),
+                });
+                return;
+        }
+    };
+    const finish = (reason) => {
+        if (settled)
+            return;
+        settled = true;
+        closeSections();
+        controller().enqueue({
+            type: "finish",
+            finishReason: reason === "tool-calls"
+                ? { unified: "tool-calls", raw: "tool_calls" }
+                : { unified: "stop", raw: "stop" },
+            usage: emptyCursorUsage(),
+        });
+        controller().close();
+    };
+    return {
+        stream,
+        emit,
+        noteCheckpoint: () => {
+            checkpointEpoch = outputEpoch;
+        },
+        replayState: () => ({ outputEpoch, checkpointEpoch, toolBoundary }),
+        suspendForRetry: () => {
+            closeSections();
+            section += 1;
+        },
+        finish,
+        fail: (error) => {
+            if (settled)
+                return;
+            settled = true;
+            controller().error(error);
+        },
+    };
+}

package/dist/providers/cursor/tool-continuation.d.ts

@@ -0,0 +1,14 @@
+import type { LanguageModelV3Prompt } from "@ai-sdk/provider";
+import type { ParkedMcpCall } from "./server-dispatch";
+export type CursorToolContinuation = {
+    readonly callId: string;
+    readonly frame: Uint8Array;
+};
+export type CursorToolContinuationErrorReason = "duplicate-result" | "malformed-result" | "mismatched-result" | "missing-result";
+export declare class CursorToolContinuationError extends Error {
+    readonly reason: CursorToolContinuationErrorReason;
+    readonly name = "CursorToolContinuationError";
+    readonly code = "CURSOR_TOOL_CONTINUATION_ERROR";
+    constructor(reason: CursorToolContinuationErrorReason);
+}
+export declare function buildCursorToolContinuations(prompt: LanguageModelV3Prompt, parkedCalls: ReadonlyMap<string, ParkedMcpCall>): readonly CursorToolContinuation[];

package/dist/providers/cursor/tool-continuation.js

@@ -0,0 +1,134 @@
+import { encodeCursorClientFrame } from "./exec-reply";
+export class CursorToolContinuationError extends Error {
+    reason;
+    name = "CursorToolContinuationError";
+    code = "CURSOR_TOOL_CONTINUATION_ERROR";
+    constructor(reason) {
+        super("Cursor tool continuation is invalid");
+        this.reason = reason;
+    }
+}
+function jsonText(value) {
+    let encoded;
+    try {
+        encoded = JSON.stringify(value);
+    }
+    catch {
+        throw new CursorToolContinuationError("malformed-result");
+    }
+    if (encoded === undefined)
+        throw new CursorToolContinuationError("malformed-result");
+    return encoded;
+}
+function decodeBase64(value) {
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+        throw new CursorToolContinuationError("malformed-result");
+    }
+    return new Uint8Array(Buffer.from(value, "base64"));
+}
+function successResult(content, isError) {
+    return {
+        kind: "success",
+        content: content.length === 0 ? [{ kind: "text", text: "" }] : content,
+        isError,
+    };
+}
+function contentResult(output) {
+    const content = [];
+    for (const part of output.value) {
+        switch (part.type) {
+            case "text":
+                content.push({ kind: "text", text: part.text });
+                break;
+            case "image-data":
+                content.push({ kind: "image", data: decodeBase64(part.data), mimeType: part.mediaType });
+                break;
+            case "file-data":
+                if (!part.mediaType.startsWith("image/")) {
+                    throw new CursorToolContinuationError("malformed-result");
+                }
+                content.push({ kind: "image", data: decodeBase64(part.data), mimeType: part.mediaType });
+                break;
+            case "file-url":
+            case "file-id":
+            case "image-url":
+            case "image-file-id":
+            case "custom":
+                throw new CursorToolContinuationError("malformed-result");
+            default:
+                return part;
+        }
+    }
+    return successResult(content, false);
+}
+function mcpResult(output) {
+    switch (output.type) {
+        case "text":
+            return successResult([{ kind: "text", text: output.value }], false);
+        case "json":
+            return successResult([{ kind: "text", text: jsonText(output.value) }], false);
+        case "content":
+            return contentResult(output);
+        case "error-text":
+            return successResult([{ kind: "text", text: output.value }], true);
+        case "error-json":
+            return successResult([{ kind: "text", text: jsonText(output.value) }], true);
+        case "execution-denied":
+            return { kind: "rejected", reason: output.reason ?? "Execution denied", isReadonly: false };
+        default:
+            return output;
+    }
+}
+function trailingResults(prompt) {
+    const results = [];
+    for (let index = prompt.length - 1; index >= 0; index -= 1) {
+        const message = prompt[index];
+        if (message?.role !== "tool")
+            break;
+        results.unshift(...message.content.filter((part) => part.type === "tool-result"));
+    }
+    return results;
+}
+function validateResults(results, parkedCalls) {
+    if (results.length === 0)
+        throw new CursorToolContinuationError("missing-result");
+    const resultsByCallId = new Map();
+    for (const result of results) {
+        if (resultsByCallId.has(result.toolCallId)) {
+            throw new CursorToolContinuationError("duplicate-result");
+        }
+        const parked = parkedCalls.get(result.toolCallId);
+        if (parked === undefined ||
+            (result.toolName !== parked.args.toolName && result.toolName !== parked.args.name)) {
+            throw new CursorToolContinuationError("mismatched-result");
+        }
+        resultsByCallId.set(result.toolCallId, result);
+    }
+    if (resultsByCallId.size !== parkedCalls.size) {
+        throw new CursorToolContinuationError("missing-result");
+    }
+    const validated = [];
+    for (const [callId, parked] of parkedCalls) {
+        const result = resultsByCallId.get(callId);
+        if (result === undefined)
+            throw new CursorToolContinuationError("missing-result");
+        validated.push({ callId, parked, result: mcpResult(result.output) });
+    }
+    return validated;
+}
+export function buildCursorToolContinuations(prompt, parkedCalls) {
+    return validateResults(trailingResults(prompt), parkedCalls).map(({ callId, parked, result }) => {
+        return {
+            callId,
+            frame: encodeCursorClientFrame({
+                kind: "exec-client-message",
+                message: {
+                    kind: "mcp-result",
+                    id: parked.execMessageId,
+                    execId: parked.execId,
+                    result,
+                },
+            }),
+        };
+    });
+}

package/dist/providers/cursor/tool-stream.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
+export declare function cursorToolParts(parsed: object, allowedTools: ReadonlyMap<string, unknown>): readonly LanguageModelV3StreamPart[];