opencode-ext-connector 0.3.0

package/dist/providers/cursor/ndjson.js

@@ -0,0 +1,100 @@
+// Derived from Nomadcxx/opencode-cursor@8e14a26c1e080382f471a729436092ef72edf34e.
+// Licensed under BSD-3-Clause. See THIRD_PARTY_NOTICES.md.
+export function cursorTextFromUnknown(value) {
+    if (typeof value === "string" && value.length > 0) {
+        return value;
+    }
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    if ("text" in value && typeof value.text === "string") {
+        return value.text;
+    }
+    if ("delta" in value && typeof value.delta === "string") {
+        return value.delta;
+    }
+    if ("result" in value && typeof value.result === "string") {
+        return value.result;
+    }
+    if ("message" in value) {
+        return cursorTextFromUnknown(value.message);
+    }
+    if ("content" in value) {
+        const content = value.content;
+        if (typeof content === "string") {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            const parts = [];
+            for (const part of content) {
+                const text = cursorTextFromUnknown(part);
+                if (text !== null) {
+                    parts.push(text);
+                }
+            }
+            return parts.length > 0 ? parts.join("") : null;
+        }
+    }
+    return null;
+}
+export function cursorResultError(value) {
+    const isError = "is_error" in value && value.is_error === true;
+    const subtype = "subtype" in value && typeof value.subtype === "string" ? value.subtype : "";
+    const exitCode = "exitCode" in value && typeof value.exitCode === "number"
+        ? value.exitCode
+        : "exit_code" in value && typeof value.exit_code === "number"
+            ? value.exit_code
+            : 0;
+    if (!isError && !subtype.includes("error") && exitCode === 0) {
+        return null;
+    }
+    return new Error(cursorTextFromUnknown(value) ?? (subtype || `cursor-agent exited ${exitCode}`));
+}
+export function extractCursorNdjsonText(stream) {
+    const parts = [];
+    let assistantText = "";
+    let resultText = "";
+    for (const line of stream.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed !== "object" || parsed === null) {
+            continue;
+        }
+        const type = "type" in parsed && typeof parsed.type === "string" ? parsed.type : "";
+        if (type === "thinking") {
+            continue;
+        }
+        if (type !== "assistant" && type !== "text" && type !== "text-delta" && type !== "result") {
+            continue;
+        }
+        const text = cursorTextFromUnknown(parsed);
+        if (text !== null) {
+            if (type === "assistant") {
+                const delta = text.startsWith(assistantText) ? text.slice(assistantText.length) : text;
+                assistantText = text;
+                if (delta.length > 0) {
+                    parts.push(delta);
+                }
+                continue;
+            }
+            if (type === "result") {
+                resultText = text;
+                continue;
+            }
+            parts.push(text);
+        }
+    }
+    if (assistantText.length === 0 && resultText.length > 0) {
+        parts.push(resultText);
+    }
+    return parts.join("");
+}

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

@@ -0,0 +1,4 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+export declare function cursorSessionKey(call: LanguageModelV3CallOptions): string | null;
+export declare function cursorIncrementalPrompt(call: LanguageModelV3CallOptions): string | null;
+export declare function cursorPromptText(call: LanguageModelV3CallOptions): string;

package/dist/providers/cursor/prompt.js

@@ -0,0 +1,142 @@
+import { createHash } from "node:crypto";
+function toolResultBody(part) {
+    if (!("output" in part)) {
+        return "";
+    }
+    const output = Reflect.get(part, "output");
+    if (typeof output === "string") {
+        return output;
+    }
+    if (typeof output === "object" && output !== null && "value" in output) {
+        const value = Reflect.get(output, "value");
+        return typeof value === "string" ? value : JSON.stringify(value);
+    }
+    return JSON.stringify(output);
+}
+function textFromContentParts(parts) {
+    const texts = [];
+    for (const part of parts) {
+        if (part.type === "text" && "text" in part && typeof part.text === "string") {
+            texts.push(part.text);
+        }
+        if (part.type === "tool-call") {
+            const id = "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : "unknown";
+            const name = "toolName" in part && typeof part.toolName === "string" ? part.toolName : "unknown";
+            const input = "input" in part ? JSON.stringify(Reflect.get(part, "input")) : "{}";
+            texts.push(`tool_call(${name}, ${id}): ${input}`);
+        }
+        if (part.type === "tool-result") {
+            const id = "toolCallId" in part && typeof part.toolCallId === "string" ? part.toolCallId : "unknown";
+            const name = "toolName" in part && typeof part.toolName === "string" ? part.toolName : undefined;
+            const body = toolResultBody(part);
+            texts.push(name === undefined
+                ? `TOOL_RESULT (call_id: ${id}): ${body}`
+                : `TOOL_RESULT (name: ${name}, call_id: ${id}): ${body}`);
+        }
+    }
+    return texts.join("");
+}
+function hash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function isMetaPrompt(text) {
+    const lower = text.toLowerCase();
+    return (lower.includes("title generator") ||
+        lower.includes("thread title") ||
+        lower.includes("generate a brief title"));
+}
+export function cursorSessionKey(call) {
+    const firstUser = call.prompt.find((message) => {
+        if (message.role !== "user") {
+            return false;
+        }
+        const text = textFromContentParts(message.content).trim();
+        return text.length > 0 && !isMetaPrompt(text);
+    });
+    if (firstUser === undefined || firstUser.role !== "user") {
+        return null;
+    }
+    const opener = textFromContentParts(firstUser.content).trim();
+    const tools = (call.tools ?? [])
+        .filter((tool) => tool.type === "function")
+        .map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? "",
+        inputSchema: tool.inputSchema,
+    }));
+    return `${hash(opener)}\0${hash(JSON.stringify(tools))}`;
+}
+export function cursorIncrementalPrompt(call) {
+    const last = call.prompt.at(-1);
+    if (last?.role === "user") {
+        const text = textFromContentParts(last.content).trim();
+        return text.length > 0 ? text : null;
+    }
+    if (last?.role !== "tool") {
+        return null;
+    }
+    let firstToolIndex = call.prompt.length - 1;
+    while (firstToolIndex > 0 && call.prompt[firstToolIndex - 1]?.role === "tool") {
+        firstToolIndex -= 1;
+    }
+    const parts = [];
+    const assistant = call.prompt[firstToolIndex - 1];
+    if (assistant?.role === "assistant") {
+        parts.push(`ASSISTANT: ${textFromContentParts(assistant.content)}`);
+    }
+    for (let index = firstToolIndex; index < call.prompt.length; index += 1) {
+        const message = call.prompt[index];
+        if (message?.role === "tool") {
+            parts.push(textFromContentParts(message.content));
+        }
+    }
+    parts.push("The above tool calls have been executed. Continue your response based on these results.");
+    return parts.join("\n\n");
+}
+function toolDefinitions(call) {
+    const tools = (call.tools ?? []).filter((tool) => tool.type === "function");
+    if (tools.length === 0) {
+        return null;
+    }
+    const definitions = tools
+        .map((tool) => {
+        const description = tool.description ?? "";
+        return `- ${tool.name}: ${description}\n  Parameters: ${JSON.stringify(tool.inputSchema)}`;
+    })
+        .join("\n");
+    return [
+        "SYSTEM: You have access to the following tools. When you need to use one, respond with a tool_call in the standard OpenAI format.",
+        "Tool guidance: prefer write/edit for file changes; use bash mainly to run commands/tests.",
+        "",
+        `Available tools:\n${definitions}`,
+    ].join("\n");
+}
+export function cursorPromptText(call) {
+    const parts = [];
+    const definitions = toolDefinitions(call);
+    if (definitions !== null) {
+        parts.push(definitions);
+    }
+    let hasToolResults = false;
+    for (const message of call.prompt) {
+        switch (message.role) {
+            case "system":
+                parts.push(`SYSTEM: ${message.content}`);
+                break;
+            case "user":
+                parts.push(`USER: ${textFromContentParts(message.content)}`);
+                break;
+            case "assistant":
+                parts.push(`ASSISTANT: ${textFromContentParts(message.content)}`);
+                break;
+            case "tool":
+                hasToolResults = true;
+                parts.push(textFromContentParts(message.content));
+                break;
+        }
+    }
+    if (hasToolResults) {
+        parts.push("The above tool calls have been executed. Continue your response based on these results.");
+    }
+    return parts.join("\n");
+}

package/dist/providers/cursor/proto/checkpoint.d.ts

@@ -0,0 +1,35 @@
+export type CheckpointMapEntry = {
+    readonly key: string;
+    readonly value: Uint8Array;
+};
+export type ConversationTokenDetails = {
+    readonly usedTokens: number;
+    readonly maxTokens: number;
+    readonly breakdown?: Uint8Array;
+};
+export type ConversationCheckpoint = {
+    readonly rootPromptMessageBlobIds: readonly Uint8Array[];
+    readonly legacyTurnBlobIds: readonly Uint8Array[];
+    readonly todoBlobIds: readonly Uint8Array[];
+    readonly pendingToolCalls: readonly string[];
+    readonly tokenDetails?: ConversationTokenDetails;
+    readonly summaryBlob?: Uint8Array;
+    readonly planBlob?: Uint8Array;
+    readonly turnBlobIds: readonly Uint8Array[];
+    readonly previousWorkspaceUris: readonly string[];
+    readonly mode?: number;
+    readonly summaryArchiveBlob?: Uint8Array;
+    readonly fileStates: readonly CheckpointMapEntry[];
+    readonly summaryArchiveBlobIds: readonly Uint8Array[];
+    readonly turnTimingMessages: readonly Uint8Array[];
+    readonly fileStatesV2: readonly CheckpointMapEntry[];
+    readonly subagentStates: readonly CheckpointMapEntry[];
+    readonly selfSummaryCount?: number;
+    readonly readPaths: readonly string[];
+    readonly trackedGitRepoBranches: readonly Uint8Array[];
+    readonly clientName?: string;
+    readonly conversationStartedTimestampMs?: Uint8Array;
+    readonly conversationStartedTimeZone?: string;
+};
+export declare function decodeConversationCheckpoint(bytes: Uint8Array): ConversationCheckpoint;
+export declare function encodeConversationCheckpoint(state: ConversationCheckpoint): Uint8Array;

package/dist/providers/cursor/proto/checkpoint.js

@@ -0,0 +1,114 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto ConversationStateStructure. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, decodeUtf8Strict, encodeBytesField, encodeInt32Field, encodeStringField, } from "../proto-wire";
+import { assertKnownFields, optionalField, optionalString, optionalUint32, repeatedFields, requiredField, requiredString, } from "./fields";
+import { encodeUnknownField } from "./unknown-field";
+function decodeTokenDetails(bytes) {
+    const context = "ConversationTokenDetails";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3], context);
+    const breakdown = optionalField(fields, { context, field: 3, wire: 2 });
+    return {
+        usedTokens: optionalUint32(fields, { context, field: 1, wire: 0 }) ?? 0,
+        maxTokens: optionalUint32(fields, { context, field: 2, wire: 0 }) ?? 0,
+        ...(breakdown === undefined ? {} : { breakdown: breakdown.bytes }),
+    };
+}
+function encodeTokenDetails(details) {
+    return concatBytes([
+        ...(details.usedTokens === 0 ? [] : [encodeInt32Field(1, details.usedTokens)]),
+        ...(details.maxTokens === 0 ? [] : [encodeInt32Field(2, details.maxTokens)]),
+        ...(details.breakdown === undefined ? [] : [encodeBytesField(3, details.breakdown)]),
+    ]);
+}
+function decodeMapEntry(bytes, context) {
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2], context);
+    return {
+        key: requiredString(fields, { context, field: 1, wire: 2 }),
+        value: requiredField(fields, { context, field: 2, wire: 2 }).bytes,
+    };
+}
+function encodeMapEntry(entry) {
+    return concatBytes([encodeStringField(1, entry.key), encodeBytesField(2, entry.value)]);
+}
+function repeatedBytes(fields, field, context) {
+    return repeatedFields(fields, { context, field, wire: 2 }).map((entry) => entry.bytes);
+}
+function repeatedStrings(fields, field, context) {
+    return repeatedFields(fields, { context, field, wire: 2 }).map((entry) => decodeUtf8Strict(entry.bytes, `${context} field ${field}`));
+}
+export function decodeConversationCheckpoint(bytes) {
+    const context = "ConversationStateStructure";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 21, 22, 26, 27], context);
+    const tokenDetails = optionalField(fields, { context, field: 5, wire: 2 });
+    const summaryBlob = optionalField(fields, { context, field: 6, wire: 2 });
+    const planBlob = optionalField(fields, { context, field: 7, wire: 2 });
+    const summaryArchiveBlob = optionalField(fields, { context, field: 11, wire: 2 });
+    const mode = optionalUint32(fields, { context, field: 10, wire: 0 });
+    const selfSummaryCount = optionalUint32(fields, { context, field: 17, wire: 0 });
+    const clientName = optionalString(fields, { context, field: 22, wire: 2 });
+    const conversationStartedTimestampMs = optionalField(fields, { context, field: 26, wire: 0 });
+    const conversationStartedTimeZone = optionalString(fields, { context, field: 27, wire: 2 });
+    return {
+        rootPromptMessageBlobIds: repeatedBytes(fields, 1, context),
+        legacyTurnBlobIds: repeatedBytes(fields, 2, context),
+        todoBlobIds: repeatedBytes(fields, 3, context),
+        pendingToolCalls: repeatedStrings(fields, 4, context),
+        ...(tokenDetails === undefined ? {} : { tokenDetails: decodeTokenDetails(tokenDetails.bytes) }),
+        ...(summaryBlob === undefined ? {} : { summaryBlob: summaryBlob.bytes }),
+        ...(planBlob === undefined ? {} : { planBlob: planBlob.bytes }),
+        turnBlobIds: repeatedBytes(fields, 8, context),
+        previousWorkspaceUris: repeatedStrings(fields, 9, context),
+        ...(mode === undefined ? {} : { mode }),
+        ...(summaryArchiveBlob === undefined ? {} : { summaryArchiveBlob: summaryArchiveBlob.bytes }),
+        fileStates: repeatedBytes(fields, 12, context).map((entry) => decodeMapEntry(entry, "ConversationStateStructure.file_states")),
+        summaryArchiveBlobIds: repeatedBytes(fields, 13, context),
+        turnTimingMessages: repeatedBytes(fields, 14, context),
+        fileStatesV2: repeatedBytes(fields, 15, context).map((entry) => decodeMapEntry(entry, "ConversationStateStructure.file_states_v2")),
+        subagentStates: repeatedBytes(fields, 16, context).map((entry) => decodeMapEntry(entry, "ConversationStateStructure.subagent_states")),
+        ...(selfSummaryCount === undefined ? {} : { selfSummaryCount }),
+        readPaths: repeatedStrings(fields, 18, context),
+        trackedGitRepoBranches: repeatedBytes(fields, 21, context),
+        ...(clientName === undefined ? {} : { clientName }),
+        ...(conversationStartedTimestampMs === undefined
+            ? {}
+            : { conversationStartedTimestampMs: conversationStartedTimestampMs.bytes }),
+        ...(conversationStartedTimeZone === undefined ? {} : { conversationStartedTimeZone }),
+    };
+}
+export function encodeConversationCheckpoint(state) {
+    return concatBytes([
+        ...state.rootPromptMessageBlobIds.map((value) => encodeBytesField(1, value)),
+        ...state.legacyTurnBlobIds.map((value) => encodeBytesField(2, value)),
+        ...state.todoBlobIds.map((value) => encodeBytesField(3, value)),
+        ...state.pendingToolCalls.map((value) => encodeStringField(4, value)),
+        ...(state.tokenDetails === undefined
+            ? []
+            : [encodeBytesField(5, encodeTokenDetails(state.tokenDetails))]),
+        ...(state.summaryBlob === undefined ? [] : [encodeBytesField(6, state.summaryBlob)]),
+        ...(state.planBlob === undefined ? [] : [encodeBytesField(7, state.planBlob)]),
+        ...state.turnBlobIds.map((value) => encodeBytesField(8, value)),
+        ...state.previousWorkspaceUris.map((value) => encodeStringField(9, value)),
+        ...(state.mode === undefined ? [] : [encodeInt32Field(10, state.mode)]),
+        ...(state.summaryArchiveBlob === undefined
+            ? []
+            : [encodeBytesField(11, state.summaryArchiveBlob)]),
+        ...state.fileStates.map((entry) => encodeBytesField(12, encodeMapEntry(entry))),
+        ...state.summaryArchiveBlobIds.map((value) => encodeBytesField(13, value)),
+        ...state.turnTimingMessages.map((value) => encodeBytesField(14, value)),
+        ...state.fileStatesV2.map((entry) => encodeBytesField(15, encodeMapEntry(entry))),
+        ...state.subagentStates.map((entry) => encodeBytesField(16, encodeMapEntry(entry))),
+        ...(state.selfSummaryCount === undefined ? [] : [encodeInt32Field(17, state.selfSummaryCount)]),
+        ...state.readPaths.map((value) => encodeStringField(18, value)),
+        ...state.trackedGitRepoBranches.map((value) => encodeBytesField(21, value)),
+        ...(state.clientName === undefined ? [] : [encodeStringField(22, state.clientName)]),
+        ...(state.conversationStartedTimestampMs === undefined
+            ? []
+            : [encodeUnknownField(26, 0, state.conversationStartedTimestampMs)]),
+        ...(state.conversationStartedTimeZone === undefined
+            ? []
+            : [encodeStringField(27, state.conversationStartedTimeZone)]),
+    ]);
+}

package/dist/providers/cursor/proto/context.d.ts

@@ -0,0 +1,64 @@
+export type SelectedImageData = {
+    readonly kind: "blob-id";
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: "data";
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: "blob-id-with-data";
+    readonly blobId: Uint8Array;
+    readonly bytes: Uint8Array;
+};
+export type SelectedImage = {
+    readonly uuid: string;
+    readonly path: string;
+    readonly mimeType: string;
+    readonly data: SelectedImageData;
+};
+export type SelectedContext = {
+    readonly selectedImages: readonly SelectedImage[];
+    readonly extraContext: readonly string[];
+};
+export type UserMessage = {
+    readonly text: string;
+    readonly messageId: string;
+    readonly selectedContext?: SelectedContext;
+    readonly mode: number;
+    readonly isSimulatedMessage?: boolean;
+    readonly bestOfNGroupId?: string;
+    readonly tryUseBestOfNPromotion?: boolean;
+    readonly richText?: string;
+    readonly selectedContextBlob: Uint8Array;
+    readonly correlationId: string;
+};
+export type ConversationAction = {
+    readonly kind: "user-message";
+    readonly userMessage?: UserMessage;
+    readonly requestContextBytes?: Uint8Array;
+    readonly sendToInteractionListener?: boolean;
+} | {
+    readonly kind: "resume";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "cancel";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "summarize";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "shell-command";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "start-plan";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "execute-plan";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "async-ask-question-completion";
+    readonly payload: Uint8Array;
+};
+export declare function decodeSelectedContext(bytes: Uint8Array): SelectedContext;
+export declare function encodeSelectedContext(context: SelectedContext): Uint8Array;
+export declare function decodeConversationAction(bytes: Uint8Array): ConversationAction;
+export declare function encodeConversationAction(action: ConversationAction): Uint8Array;

package/dist/providers/cursor/proto/context.js

@@ -0,0 +1,178 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto conversation context fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, decodeUtf8Strict, encodeBoolField, encodeBytesField, encodeInt32Field, encodeStringField, } from "../proto-wire";
+import { CursorProtocolError, unreachableVariant } from "./errors";
+import { assertKnownFields, oneofField, optionalBool, optionalField, optionalString, repeatedFields, requiredField, requiredString, requiredUint32, } from "./fields";
+function decodeImageData(bytes, field) {
+    switch (field) {
+        case 1:
+            return { kind: "blob-id", bytes };
+        case 8:
+            return { kind: "data", bytes };
+        case 9: {
+            const context = "SelectedImage.BlobIdWithData";
+            const fields = decodeFieldsStrict(bytes, { context });
+            assertKnownFields(fields, [1, 2], context);
+            return {
+                kind: "blob-id-with-data",
+                blobId: requiredField(fields, { context, field: 1, wire: 2 }).bytes,
+                bytes: requiredField(fields, { context, field: 2, wire: 2 }).bytes,
+            };
+        }
+        default:
+            throw new CursorProtocolError("malformed", "SelectedImage", "image data variant is absent");
+    }
+}
+function encodeImageData(data) {
+    switch (data.kind) {
+        case "blob-id":
+            return encodeBytesField(1, data.bytes);
+        case "data":
+            return encodeBytesField(8, data.bytes);
+        case "blob-id-with-data":
+            return encodeBytesField(9, concatBytes([encodeBytesField(1, data.blobId), encodeBytesField(2, data.bytes)]));
+        default:
+            return unreachableVariant(data, "SelectedImage.data");
+    }
+}
+function decodeSelectedImage(bytes) {
+    const context = "SelectedImage";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 7, 8, 9], context);
+    const data = oneofField(fields, [1, 8, 9], context);
+    return {
+        uuid: requiredString(fields, { context, field: 2, wire: 2 }),
+        path: optionalString(fields, { context, field: 3, wire: 2 }) ?? "",
+        mimeType: requiredString(fields, { context, field: 7, wire: 2 }),
+        data: decodeImageData(data.bytes, data.field),
+    };
+}
+function encodeSelectedImage(image) {
+    return concatBytes([
+        encodeImageData(image.data),
+        encodeStringField(2, image.uuid),
+        ...(image.path === "" ? [] : [encodeStringField(3, image.path)]),
+        encodeStringField(7, image.mimeType),
+    ]);
+}
+export function decodeSelectedContext(bytes) {
+    const context = "SelectedContext";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 3], context);
+    return {
+        selectedImages: repeatedFields(fields, { context, field: 1, wire: 2 }).map((entry) => decodeSelectedImage(entry.bytes)),
+        extraContext: repeatedFields(fields, { context, field: 3, wire: 2 }).map((entry) => decodeUtf8Strict(entry.bytes, `${context} field 3`)),
+    };
+}
+export function encodeSelectedContext(context) {
+    return concatBytes([
+        ...context.selectedImages.map((image) => encodeBytesField(1, encodeSelectedImage(image))),
+        ...context.extraContext.map((value) => encodeStringField(3, value)),
+    ]);
+}
+function decodeUserMessage(bytes) {
+    const context = "UserMessage";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5, 6, 7, 8, 10, 17], context);
+    const selectedContext = optionalField(fields, { context, field: 3, wire: 2 });
+    const isSimulatedMessage = optionalBool(fields, { context, field: 5, wire: 0 });
+    const bestOfNGroupId = optionalString(fields, { context, field: 6, wire: 2 });
+    const tryUseBestOfNPromotion = optionalBool(fields, { context, field: 7, wire: 0 });
+    const richText = optionalString(fields, { context, field: 8, wire: 2 });
+    const base = {
+        text: requiredString(fields, { context, field: 1, wire: 2 }),
+        messageId: requiredString(fields, { context, field: 2, wire: 2 }),
+        mode: requiredUint32(fields, { context, field: 4, wire: 0 }),
+        selectedContextBlob: requiredField(fields, { context, field: 10, wire: 2 }).bytes,
+        correlationId: requiredString(fields, { context, field: 17, wire: 2 }),
+    };
+    return {
+        ...base,
+        ...(selectedContext === undefined
+            ? {}
+            : { selectedContext: decodeSelectedContext(selectedContext.bytes) }),
+        ...(isSimulatedMessage === undefined ? {} : { isSimulatedMessage }),
+        ...(bestOfNGroupId === undefined ? {} : { bestOfNGroupId }),
+        ...(tryUseBestOfNPromotion === undefined ? {} : { tryUseBestOfNPromotion }),
+        ...(richText === undefined ? {} : { richText }),
+    };
+}
+function encodeUserMessage(message) {
+    return concatBytes([
+        encodeStringField(1, message.text),
+        encodeStringField(2, message.messageId),
+        ...(message.selectedContext === undefined
+            ? []
+            : [encodeBytesField(3, encodeSelectedContext(message.selectedContext))]),
+        encodeInt32Field(4, message.mode),
+        ...(message.isSimulatedMessage === undefined
+            ? []
+            : [encodeBoolField(5, message.isSimulatedMessage)]),
+        ...(message.bestOfNGroupId === undefined ? [] : [encodeStringField(6, message.bestOfNGroupId)]),
+        ...(message.tryUseBestOfNPromotion === undefined
+            ? []
+            : [encodeBoolField(7, message.tryUseBestOfNPromotion)]),
+        ...(message.richText === undefined ? [] : [encodeStringField(8, message.richText)]),
+        encodeBytesField(10, message.selectedContextBlob),
+        encodeStringField(17, message.correlationId),
+    ]);
+}
+export function decodeConversationAction(bytes) {
+    const context = "ConversationAction";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5, 6, 7, 8], context);
+    const action = oneofField(fields, [1, 2, 3, 4, 5, 6, 7, 8], context);
+    if (action.field !== 1) {
+        const kinds = [
+            "resume",
+            "cancel",
+            "summarize",
+            "shell-command",
+            "start-plan",
+            "execute-plan",
+            "async-ask-question-completion",
+        ];
+        const kind = kinds[action.field - 2];
+        if (kind === undefined) {
+            throw new CursorProtocolError("malformed", context, "action variant is absent");
+        }
+        return { kind, payload: action.bytes };
+    }
+    const actionContext = "UserMessageAction";
+    const actionFields = decodeFieldsStrict(action.bytes, { context: actionContext });
+    assertKnownFields(actionFields, [1, 2, 3], actionContext);
+    const userMessage = optionalField(actionFields, { context: actionContext, field: 1, wire: 2 });
+    const requestContext = optionalField(actionFields, { context: actionContext, field: 2, wire: 2 });
+    const listener = optionalBool(actionFields, { context: actionContext, field: 3, wire: 0 });
+    return {
+        kind: "user-message",
+        ...(userMessage === undefined ? {} : { userMessage: decodeUserMessage(userMessage.bytes) }),
+        ...(requestContext === undefined ? {} : { requestContextBytes: requestContext.bytes }),
+        ...(listener === undefined ? {} : { sendToInteractionListener: listener }),
+    };
+}
+export function encodeConversationAction(action) {
+    if (action.kind !== "user-message") {
+        const fields = {
+            resume: 2,
+            cancel: 3,
+            summarize: 4,
+            "shell-command": 5,
+            "start-plan": 6,
+            "execute-plan": 7,
+            "async-ask-question-completion": 8,
+        };
+        return encodeBytesField(fields[action.kind], action.payload);
+    }
+    return encodeBytesField(1, concatBytes([
+        ...(action.userMessage === undefined
+            ? []
+            : [encodeBytesField(1, encodeUserMessage(action.userMessage))]),
+        ...(action.requestContextBytes === undefined
+            ? []
+            : [encodeBytesField(2, action.requestContextBytes)]),
+        ...(action.sendToInteractionListener === undefined
+            ? []
+            : [encodeBoolField(3, action.sendToInteractionListener)]),
+    ]));
+}

package/dist/providers/cursor/proto/errors.d.ts

@@ -0,0 +1,16 @@
+export type CursorProtocolReason = "malformed" | "truncated" | "wrong-wire" | "oversized" | "unsupported-flags";
+export declare class CursorProtocolError extends Error {
+    readonly reason: CursorProtocolReason;
+    readonly context: string;
+    readonly name = "CursorProtocolError";
+    readonly code = "CURSOR_PROTOCOL_ERROR";
+    constructor(reason: CursorProtocolReason, context: string, detail: string);
+}
+export declare class CursorProtocolDriftError extends Error {
+    readonly context: string;
+    readonly field: number;
+    readonly name = "CursorProtocolDriftError";
+    readonly code = "CURSOR_PROTOCOL_DRIFT";
+    constructor(context: string, field: number, detail?: string);
+}
+export declare function unreachableVariant(value: never, context: string): never;