opencode-ext-connector 0.3.0

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

@@ -0,0 +1,11 @@
+export type RequestedModelParameter = {
+    readonly id: string;
+    readonly value: string;
+};
+export type RequestedModel = {
+    readonly modelId: string;
+    readonly maxMode: boolean;
+    readonly parameters: readonly RequestedModelParameter[];
+};
+export declare function decodeRequestedModel(bytes: Uint8Array): RequestedModel;
+export declare function encodeRequestedModel(model: RequestedModel): Uint8Array;

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

@@ -0,0 +1,36 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto RequestedModel. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBoolField, encodeBytesField, encodeStringField, } from "../proto-wire";
+import { assertKnownFields, optionalBool, optionalString, repeatedFields } from "./fields";
+function decodeParameter(bytes) {
+    const context = "RequestedModel.Parameter";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2], context);
+    return {
+        id: optionalString(fields, { context, field: 1, wire: 2 }) ?? "",
+        value: optionalString(fields, { context, field: 2, wire: 2 }) ?? "",
+    };
+}
+function encodeParameter(parameter) {
+    return concatBytes([
+        ...(parameter.id === "" ? [] : [encodeStringField(1, parameter.id)]),
+        ...(parameter.value === "" ? [] : [encodeStringField(2, parameter.value)]),
+    ]);
+}
+export function decodeRequestedModel(bytes) {
+    const context = "RequestedModel";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3], context);
+    return {
+        modelId: optionalString(fields, { context, field: 1, wire: 2 }) ?? "",
+        maxMode: optionalBool(fields, { context, field: 2, wire: 0 }) ?? false,
+        parameters: repeatedFields(fields, { context, field: 3, wire: 2 }).map((entry) => decodeParameter(entry.bytes)),
+    };
+}
+export function encodeRequestedModel(model) {
+    return concatBytes([
+        ...(model.modelId === "" ? [] : [encodeStringField(1, model.modelId)]),
+        ...(model.maxMode ? [encodeBoolField(2, true)] : []),
+        ...model.parameters.map((parameter) => encodeBytesField(3, encodeParameter(parameter))),
+    ]);
+}

package/dist/providers/cursor/proto/output-location.d.ts

@@ -0,0 +1,7 @@
+export type OutputLocation = {
+    readonly filePath: string;
+    readonly sizeBytes: bigint;
+    readonly lineCount: bigint;
+};
+export declare function decodeOutputLocation(bytes: Uint8Array): OutputLocation;
+export declare function encodeOutputLocation(location: OutputLocation): Uint8Array;

package/dist/providers/cursor/proto/output-location.js

@@ -0,0 +1,53 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto OutputLocation fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeStringField } from "../proto-wire";
+import { CursorProtocolError } from "./errors";
+import { assertKnownFields, optionalField, optionalString } from "./fields";
+import { encodeUnknownField } from "./unknown-field";
+const UINT64_MODULUS = 1n << 64n;
+const INT64_SIGN = 1n << 63n;
+function decodeInt64(bytes) {
+    let value = 0n;
+    let shift = 0n;
+    for (const byte of bytes) {
+        value |= BigInt(byte & 0x7f) << shift;
+        shift += 7n;
+    }
+    return value >= INT64_SIGN ? value - UINT64_MODULUS : value;
+}
+function encodeInt64(value) {
+    if (value < -INT64_SIGN || value >= INT64_SIGN) {
+        throw new CursorProtocolError("malformed", "protobuf int64", "value is out of range");
+    }
+    const output = [];
+    let remaining = value < 0n ? value + UINT64_MODULUS : value;
+    do {
+        const byte = Number(remaining & 0x7fn);
+        remaining >>= 7n;
+        output.push(remaining === 0n ? byte : byte | 0x80);
+    } while (remaining !== 0n);
+    return Uint8Array.from(output);
+}
+export function decodeOutputLocation(bytes) {
+    const context = "OutputLocation";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3], context);
+    const size = optionalField(fields, { context, field: 2, wire: 0 });
+    const lines = optionalField(fields, { context, field: 3, wire: 0 });
+    return {
+        filePath: optionalString(fields, { context, field: 1, wire: 2 }) ?? "",
+        sizeBytes: size === undefined ? 0n : decodeInt64(size.bytes),
+        lineCount: lines === undefined ? 0n : decodeInt64(lines.bytes),
+    };
+}
+export function encodeOutputLocation(location) {
+    return concatBytes([
+        ...(location.filePath === "" ? [] : [encodeStringField(1, location.filePath)]),
+        ...(location.sizeBytes === 0n
+            ? []
+            : [encodeUnknownField(2, 0, encodeInt64(location.sizeBytes))]),
+        ...(location.lineCount === 0n
+            ? []
+            : [encodeUnknownField(3, 0, encodeInt64(location.lineCount))]),
+    ]);
+}

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

@@ -0,0 +1,16 @@
+import { type ConversationCheckpoint } from "./checkpoint";
+import type { McpToolDefinition } from "./mcp";
+import { type RequestedModel } from "./model";
+export type PrewarmRequest = {
+    readonly modelDetails?: Uint8Array;
+    readonly requestedModel?: RequestedModel;
+    readonly conversationId?: string;
+    readonly conversationState?: ConversationCheckpoint;
+    readonly mcpTools: readonly McpToolDefinition[];
+    readonly mcpFileSystemOptions?: Uint8Array;
+    readonly bestOfNGroupId?: string;
+    readonly tryUseBestOfNPromotion?: boolean;
+    readonly customSystemPrompt?: string;
+};
+export declare function decodePrewarmRequest(bytes: Uint8Array): PrewarmRequest;
+export declare function encodePrewarmRequest(request: PrewarmRequest): Uint8Array;

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

@@ -0,0 +1,68 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto PrewarmRequest fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBoolField, encodeBytesField, encodeStringField, } from "../proto-wire";
+import { decodeConversationCheckpoint, encodeConversationCheckpoint, } from "./checkpoint";
+import { assertKnownFields, optionalBool, optionalField, optionalString } from "./fields";
+import { decodeRequestedModel, encodeRequestedModel } from "./model";
+import { decodeMcpTools, encodeMcpTools } from "./run-request";
+function optionalOpaque(fields, field, context) {
+    const value = optionalField(fields, { context, field, wire: 2 });
+    if (value !== undefined) {
+        decodeFieldsStrict(value.bytes, { context: `${context} field ${field}` });
+    }
+    return value?.bytes;
+}
+export function decodePrewarmRequest(bytes) {
+    const context = "PrewarmRequest";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5, 6, 7, 8, 9], context);
+    const modelDetails = optionalOpaque(fields, 1, context);
+    const requestedModel = optionalField(fields, { context, field: 9, wire: 2 });
+    const conversationId = optionalString(fields, { context, field: 2, wire: 2 });
+    const conversationState = optionalField(fields, { context, field: 3, wire: 2 });
+    const mcpTools = optionalField(fields, { context, field: 4, wire: 2 });
+    const mcpFileSystemOptions = optionalOpaque(fields, 5, context);
+    const bestOfNGroupId = optionalString(fields, { context, field: 6, wire: 2 });
+    const tryUseBestOfNPromotion = optionalBool(fields, { context, field: 7, wire: 0 });
+    const customSystemPrompt = optionalString(fields, { context, field: 8, wire: 2 });
+    return {
+        ...(modelDetails === undefined ? {} : { modelDetails }),
+        ...(requestedModel === undefined
+            ? {}
+            : { requestedModel: decodeRequestedModel(requestedModel.bytes) }),
+        ...(conversationId === undefined ? {} : { conversationId }),
+        ...(conversationState === undefined
+            ? {}
+            : { conversationState: decodeConversationCheckpoint(conversationState.bytes) }),
+        mcpTools: mcpTools === undefined ? [] : decodeMcpTools(mcpTools.bytes),
+        ...(mcpFileSystemOptions === undefined ? {} : { mcpFileSystemOptions }),
+        ...(bestOfNGroupId === undefined ? {} : { bestOfNGroupId }),
+        ...(tryUseBestOfNPromotion === undefined ? {} : { tryUseBestOfNPromotion }),
+        ...(customSystemPrompt === undefined ? {} : { customSystemPrompt }),
+    };
+}
+export function encodePrewarmRequest(request) {
+    return concatBytes([
+        ...(request.modelDetails === undefined ? [] : [encodeBytesField(1, request.modelDetails)]),
+        ...(request.conversationId === undefined ? [] : [encodeStringField(2, request.conversationId)]),
+        ...(request.conversationState === undefined
+            ? []
+            : [encodeBytesField(3, encodeConversationCheckpoint(request.conversationState))]),
+        ...(request.mcpTools.length === 0
+            ? []
+            : [encodeBytesField(4, encodeMcpTools(request.mcpTools))]),
+        ...(request.mcpFileSystemOptions === undefined
+            ? []
+            : [encodeBytesField(5, request.mcpFileSystemOptions)]),
+        ...(request.bestOfNGroupId === undefined ? [] : [encodeStringField(6, request.bestOfNGroupId)]),
+        ...(request.tryUseBestOfNPromotion === undefined
+            ? []
+            : [encodeBoolField(7, request.tryUseBestOfNPromotion)]),
+        ...(request.customSystemPrompt === undefined
+            ? []
+            : [encodeStringField(8, request.customSystemPrompt)]),
+        ...(request.requestedModel === undefined
+            ? []
+            : [encodeBytesField(9, encodeRequestedModel(request.requestedModel))]),
+    ]);
+}

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

@@ -0,0 +1,16 @@
+import { type McpToolDefinition } from "./mcp";
+export type RequestContext = {
+    readonly tools: readonly McpToolDefinition[];
+};
+export type RequestContextResult = {
+    readonly kind: "success";
+    readonly requestContext: RequestContext;
+} | {
+    readonly kind: "error";
+    readonly error: string;
+} | {
+    readonly kind: "rejected";
+    readonly reason: string;
+};
+export declare function decodeRequestContextResult(bytes: Uint8Array): RequestContextResult;
+export declare function encodeRequestContextResult(result: RequestContextResult): Uint8Array;

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

@@ -0,0 +1,58 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto request-context fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, encodeStringField } from "../proto-wire";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { assertKnownFields, oneofField, repeatedFields, requiredString } from "./fields";
+import { decodeMcpToolDefinition, encodeMcpToolDefinition } from "./mcp";
+function decodeRequestContext(bytes) {
+    const context = "RequestContext";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [7], context);
+    return {
+        tools: repeatedFields(fields, { context, field: 7, wire: 2 }).map((entry) => decodeMcpToolDefinition(entry.bytes)),
+    };
+}
+function encodeRequestContext(context) {
+    return concatBytes(context.tools.map((tool) => encodeBytesField(7, encodeMcpToolDefinition(tool))));
+}
+function decodeSingleString(bytes, context) {
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1], context);
+    return requiredString(fields, { context, field: 1, wire: 2 });
+}
+export function decodeRequestContextResult(bytes) {
+    const context = "RequestContextResult";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3], context);
+    const result = oneofField(fields, [1, 2, 3], context);
+    switch (result.field) {
+        case 1: {
+            const successContext = "RequestContextSuccess";
+            const success = decodeFieldsStrict(result.bytes, { context: successContext });
+            assertKnownFields(success, [1], successContext);
+            const requestContext = oneofField(success, [1], successContext);
+            return { kind: "success", requestContext: decodeRequestContext(requestContext.bytes) };
+        }
+        case 2:
+            return { kind: "error", error: decodeSingleString(result.bytes, "RequestContextError") };
+        case 3:
+            return {
+                kind: "rejected",
+                reason: decodeSingleString(result.bytes, "RequestContextRejected"),
+            };
+        default:
+            throw new CursorProtocolDriftError(context, result.field);
+    }
+}
+export function encodeRequestContextResult(result) {
+    switch (result.kind) {
+        case "success":
+            return encodeBytesField(1, encodeBytesField(1, encodeRequestContext(result.requestContext)));
+        case "error":
+            return encodeBytesField(2, encodeStringField(1, result.error));
+        case "rejected":
+            return encodeBytesField(3, encodeStringField(1, result.reason));
+        default:
+            return unreachableVariant(result, "RequestContextResult");
+    }
+}

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

@@ -0,0 +1,44 @@
+import { type ProtoDecodeOptions } from "../proto-wire";
+import { type ConversationAction } from "./context";
+import { type ExecClientMessage } from "./exec";
+import { type ExecClientControl } from "./exec-control";
+import { type ProtoDriftMetadata } from "./fields";
+import { type InteractionResponse } from "./interaction-query";
+import { type KvClientMessage } from "./kv";
+import { type PrewarmRequest } from "./prewarm";
+import { type AgentRunRequest } from "./run-request";
+export type { PrewarmRequest } from "./prewarm";
+export { type AgentRunRequest, decodeAgentRunRequest, encodeAgentRunRequest } from "./run-request";
+export type AgentClientMessage = ({
+    readonly kind: "run-request";
+    readonly request: AgentRunRequest;
+} | {
+    readonly kind: "exec-client-message";
+    readonly message: ExecClientMessage;
+} | {
+    readonly kind: "exec-client-control";
+    readonly control: ExecClientControl;
+} | {
+    readonly kind: "kv-client-message";
+    readonly message: KvClientMessage;
+} | {
+    readonly kind: "conversation-action";
+    readonly action: ConversationAction;
+} | {
+    readonly kind: "interaction-response";
+    readonly response: InteractionResponse;
+} | {
+    readonly kind: "client-heartbeat";
+} | {
+    readonly kind: "prewarm-request";
+    readonly request: PrewarmRequest;
+} | {
+    readonly kind: "unknown-oneof";
+    readonly field: number;
+    readonly payload: Uint8Array;
+    readonly drift: ProtoDriftMetadata;
+}) & {
+    readonly drift?: ProtoDriftMetadata;
+};
+export declare function decodeAgentClientMessage(bytes: Uint8Array, options?: ProtoDecodeOptions): AgentClientMessage;
+export declare function encodeAgentClientMessage(message: AgentClientMessage): Uint8Array;

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

@@ -0,0 +1,111 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto AgentClientMessage. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, } from "../proto-wire";
+import { decodeConversationAction, encodeConversationAction, } from "./context";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { decodeExecClientMessage, encodeExecClientMessage } from "./exec";
+import { decodeExecClientControl, encodeExecClientControl, } from "./exec-control";
+import { assertKnownFields, collectDriftMetadata, encodeDriftFields, oneofField, } from "./fields";
+import { decodeInteractionResponse, encodeInteractionResponse, } from "./interaction-query";
+import { decodeKvClientMessage, encodeKvClientMessage } from "./kv";
+import { decodePrewarmRequest, encodePrewarmRequest } from "./prewarm";
+import { decodeAgentRunRequest, encodeAgentRunRequest } from "./run-request";
+export { decodeAgentRunRequest, encodeAgentRunRequest } from "./run-request";
+export function decodeAgentClientMessage(bytes, options = {}) {
+    const context = "AgentClientMessage";
+    const fields = decodeFieldsStrict(bytes, { ...options, context });
+    const allowed = [1, 2, 3, 4, 5, 6, 7, 8];
+    const known = fields.filter((field) => allowed.includes(field.field));
+    if (known.length === 0) {
+        const message = oneofField(fields, fields.map((field) => field.field), context);
+        const drift = collectDriftMetadata(fields, allowed, true);
+        if (drift === undefined)
+            throw new CursorProtocolDriftError(context, message.field);
+        return { kind: "unknown-oneof", field: message.field, payload: message.bytes, drift };
+    }
+    const drift = collectDriftMetadata(fields, allowed);
+    const message = oneofField(fields, allowed, context);
+    switch (message.field) {
+        case 1:
+            return {
+                kind: "run-request",
+                request: decodeAgentRunRequest(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 2:
+            return {
+                kind: "exec-client-message",
+                message: decodeExecClientMessage(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 3:
+            return {
+                kind: "kv-client-message",
+                message: decodeKvClientMessage(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 4:
+            return {
+                kind: "conversation-action",
+                action: decodeConversationAction(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 5:
+            return {
+                kind: "exec-client-control",
+                control: decodeExecClientControl(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 6:
+            return {
+                kind: "interaction-response",
+                response: decodeInteractionResponse(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 7:
+            assertKnownFields(decodeFieldsStrict(message.bytes, { context: "ClientHeartbeat" }), [], "ClientHeartbeat");
+            return { kind: "client-heartbeat", ...(drift === undefined ? {} : { drift }) };
+        case 8:
+            return {
+                kind: "prewarm-request",
+                request: decodePrewarmRequest(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        default:
+            throw new CursorProtocolDriftError(context, message.field);
+    }
+}
+export function encodeAgentClientMessage(message) {
+    let encoded;
+    switch (message.kind) {
+        case "run-request":
+            encoded = encodeBytesField(1, encodeAgentRunRequest(message.request));
+            break;
+        case "exec-client-message":
+            encoded = encodeBytesField(2, encodeExecClientMessage(message.message));
+            break;
+        case "exec-client-control":
+            encoded = encodeBytesField(5, encodeExecClientControl(message.control));
+            break;
+        case "kv-client-message":
+            encoded = encodeBytesField(3, encodeKvClientMessage(message.message));
+            break;
+        case "conversation-action":
+            encoded = encodeBytesField(4, encodeConversationAction(message.action));
+            break;
+        case "interaction-response":
+            encoded = encodeBytesField(6, encodeInteractionResponse(message.response));
+            break;
+        case "client-heartbeat":
+            encoded = encodeBytesField(7, new Uint8Array());
+            break;
+        case "prewarm-request":
+            encoded = encodeBytesField(8, encodePrewarmRequest(message.request));
+            break;
+        case "unknown-oneof":
+            return encodeBytesField(message.field, message.payload);
+        default:
+            return unreachableVariant(message, "AgentClientMessage");
+    }
+    return concatBytes([encoded, encodeDriftFields(message.drift)]);
+}

package/dist/providers/cursor/proto/run-request.d.ts

@@ -0,0 +1,19 @@
+import { type ConversationCheckpoint } from "./checkpoint";
+import { type ConversationAction } from "./context";
+import { type McpToolDefinition } from "./mcp";
+import { type RequestedModel } from "./model";
+export type AgentRunRequest = {
+    readonly conversationState: ConversationCheckpoint;
+    readonly action: ConversationAction;
+    readonly modelDetails?: Uint8Array;
+    readonly mcpTools: readonly McpToolDefinition[];
+    readonly conversationId?: string;
+    readonly mcpFileSystemOptions?: Uint8Array;
+    readonly skillOptions?: Uint8Array;
+    readonly customSystemPrompt?: string;
+    readonly requestedModel?: RequestedModel;
+};
+export declare function decodeMcpTools(bytes: Uint8Array): readonly McpToolDefinition[];
+export declare function encodeMcpTools(tools: readonly McpToolDefinition[]): Uint8Array;
+export declare function decodeAgentRunRequest(bytes: Uint8Array): AgentRunRequest;
+export declare function encodeAgentRunRequest(request: AgentRunRequest): Uint8Array;

package/dist/providers/cursor/proto/run-request.js

@@ -0,0 +1,68 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto AgentRunRequest. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, encodeStringField } from "../proto-wire";
+import { decodeConversationCheckpoint, encodeConversationCheckpoint, } from "./checkpoint";
+import { decodeConversationAction, encodeConversationAction, } from "./context";
+import { assertKnownFields, optionalField, optionalString, repeatedFields, requiredField, } from "./fields";
+import { decodeMcpToolDefinition, encodeMcpToolDefinition } from "./mcp";
+import { decodeRequestedModel, encodeRequestedModel } from "./model";
+export function decodeMcpTools(bytes) {
+    const context = "McpTools";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1], context);
+    return repeatedFields(fields, { context, field: 1, wire: 2 }).map((entry) => decodeMcpToolDefinition(entry.bytes));
+}
+export function encodeMcpTools(tools) {
+    return concatBytes(tools.map((tool) => encodeBytesField(1, encodeMcpToolDefinition(tool))));
+}
+function optionalOpaque(fields, field, context) {
+    const value = optionalField(fields, { context, field, wire: 2 });
+    if (value === undefined) {
+        return undefined;
+    }
+    decodeFieldsStrict(value.bytes, { context: `${context} field ${field}` });
+    return value.bytes;
+}
+export function decodeAgentRunRequest(bytes) {
+    const context = "AgentRunRequest";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5, 6, 7, 8, 9], context);
+    const modelDetails = optionalOpaque(fields, 3, context);
+    const conversationId = optionalString(fields, { context, field: 5, wire: 2 });
+    const mcpFileSystemOptions = optionalOpaque(fields, 6, context);
+    const skillOptions = optionalOpaque(fields, 7, context);
+    const customSystemPrompt = optionalString(fields, { context, field: 8, wire: 2 });
+    const requestedModel = optionalField(fields, { context, field: 9, wire: 2 });
+    return {
+        conversationState: decodeConversationCheckpoint(requiredField(fields, { context, field: 1, wire: 2 }).bytes),
+        action: decodeConversationAction(requiredField(fields, { context, field: 2, wire: 2 }).bytes),
+        ...(modelDetails === undefined ? {} : { modelDetails }),
+        mcpTools: decodeMcpTools(requiredField(fields, { context, field: 4, wire: 2 }).bytes),
+        ...(conversationId === undefined ? {} : { conversationId }),
+        ...(mcpFileSystemOptions === undefined ? {} : { mcpFileSystemOptions }),
+        ...(skillOptions === undefined ? {} : { skillOptions }),
+        ...(customSystemPrompt === undefined ? {} : { customSystemPrompt }),
+        ...(requestedModel === undefined
+            ? {}
+            : { requestedModel: decodeRequestedModel(requestedModel.bytes) }),
+    };
+}
+export function encodeAgentRunRequest(request) {
+    return concatBytes([
+        encodeBytesField(1, encodeConversationCheckpoint(request.conversationState)),
+        encodeBytesField(2, encodeConversationAction(request.action)),
+        ...(request.modelDetails === undefined ? [] : [encodeBytesField(3, request.modelDetails)]),
+        encodeBytesField(4, encodeMcpTools(request.mcpTools)),
+        ...(request.conversationId === undefined ? [] : [encodeStringField(5, request.conversationId)]),
+        ...(request.mcpFileSystemOptions === undefined
+            ? []
+            : [encodeBytesField(6, request.mcpFileSystemOptions)]),
+        ...(request.skillOptions === undefined ? [] : [encodeBytesField(7, request.skillOptions)]),
+        ...(request.customSystemPrompt === undefined
+            ? []
+            : [encodeStringField(8, request.customSystemPrompt)]),
+        ...(request.requestedModel === undefined
+            ? []
+            : [encodeBytesField(9, encodeRequestedModel(request.requestedModel))]),
+    ]);
+}

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

@@ -0,0 +1,35 @@
+import { type ProtoDecodeOptions } from "../proto-wire";
+import { type ConversationCheckpoint } from "./checkpoint";
+import { type ExecServerMessage } from "./exec";
+import { type ExecServerControl } from "./exec-control";
+import { type ProtoDriftMetadata } from "./fields";
+import { type InteractionQuery, type InteractionUpdate } from "./interaction";
+import { type KvServerMessage } from "./kv";
+export type AgentServerMessage = ({
+    readonly kind: "interaction-update";
+    readonly update: InteractionUpdate;
+} | {
+    readonly kind: "exec-server-message";
+    readonly message: ExecServerMessage;
+} | {
+    readonly kind: "exec-server-control";
+    readonly control: ExecServerControl;
+} | {
+    readonly kind: "conversation-checkpoint-update";
+    readonly checkpoint: ConversationCheckpoint;
+} | {
+    readonly kind: "kv-server-message";
+    readonly message: KvServerMessage;
+} | {
+    readonly kind: "interaction-query";
+    readonly query: InteractionQuery;
+} | {
+    readonly kind: "unknown-oneof";
+    readonly field: number;
+    readonly payload: Uint8Array;
+    readonly drift: ProtoDriftMetadata;
+}) & {
+    readonly drift?: ProtoDriftMetadata;
+};
+export declare function decodeAgentServerMessage(bytes: Uint8Array, options?: ProtoDecodeOptions): AgentServerMessage;
+export declare function encodeAgentServerMessage(message: AgentServerMessage): Uint8Array;

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

@@ -0,0 +1,93 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto AgentServerMessage. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, } from "../proto-wire";
+import { decodeConversationCheckpoint, encodeConversationCheckpoint, } from "./checkpoint";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { decodeExecServerMessage, encodeExecServerMessage } from "./exec";
+import { decodeExecServerControl, encodeExecServerControl, } from "./exec-control";
+import { collectDriftMetadata, encodeDriftFields, oneofField, } from "./fields";
+import { decodeInteractionQuery, decodeInteractionUpdate, encodeInteractionQuery, encodeInteractionUpdate, } from "./interaction";
+import { decodeKvServerMessage, encodeKvServerMessage } from "./kv";
+export function decodeAgentServerMessage(bytes, options = {}) {
+    const context = "AgentServerMessage";
+    const fields = decodeFieldsStrict(bytes, { ...options, context });
+    const allowed = [1, 2, 3, 4, 5, 7];
+    const known = fields.filter((field) => allowed.includes(field.field));
+    if (known.length === 0) {
+        const message = oneofField(fields, fields.map((field) => field.field), context);
+        const drift = collectDriftMetadata(fields, allowed, true);
+        if (drift === undefined)
+            throw new CursorProtocolDriftError(context, message.field);
+        return { kind: "unknown-oneof", field: message.field, payload: message.bytes, drift };
+    }
+    const message = oneofField(fields, allowed, context);
+    const drift = collectDriftMetadata(fields, allowed);
+    switch (message.field) {
+        case 1:
+            return {
+                kind: "interaction-update",
+                update: decodeInteractionUpdate(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 2:
+            return {
+                kind: "exec-server-message",
+                message: decodeExecServerMessage(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 3:
+            return {
+                kind: "conversation-checkpoint-update",
+                checkpoint: decodeConversationCheckpoint(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 4:
+            return {
+                kind: "kv-server-message",
+                message: decodeKvServerMessage(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 5:
+            return {
+                kind: "exec-server-control",
+                control: decodeExecServerControl(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        case 7:
+            return {
+                kind: "interaction-query",
+                query: decodeInteractionQuery(message.bytes),
+                ...(drift === undefined ? {} : { drift }),
+            };
+        default:
+            throw new CursorProtocolDriftError(context, message.field);
+    }
+}
+export function encodeAgentServerMessage(message) {
+    let encoded;
+    switch (message.kind) {
+        case "interaction-update":
+            encoded = encodeBytesField(1, encodeInteractionUpdate(message.update));
+            break;
+        case "exec-server-message":
+            encoded = encodeBytesField(2, encodeExecServerMessage(message.message));
+            break;
+        case "conversation-checkpoint-update":
+            encoded = encodeBytesField(3, encodeConversationCheckpoint(message.checkpoint));
+            break;
+        case "kv-server-message":
+            encoded = encodeBytesField(4, encodeKvServerMessage(message.message));
+            break;
+        case "exec-server-control":
+            encoded = encodeBytesField(5, encodeExecServerControl(message.control));
+            break;
+        case "interaction-query":
+            encoded = encodeBytesField(7, encodeInteractionQuery(message.query));
+            break;
+        case "unknown-oneof":
+            return encodeBytesField(message.field, message.payload);
+        default:
+            return unreachableVariant(message, "AgentServerMessage");
+    }
+    return concatBytes([encoded, encodeDriftFields(message.drift)]);
+}

package/dist/providers/cursor/proto/unknown-field.d.ts

@@ -0,0 +1 @@
+export declare function encodeUnknownField(field: number, wire: number, bytes: Uint8Array): Uint8Array;