opencode-ext-connector 0.3.0

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

@@ -0,0 +1,26 @@
+export class CursorProtocolError extends Error {
+    reason;
+    context;
+    name = "CursorProtocolError";
+    code = "CURSOR_PROTOCOL_ERROR";
+    constructor(reason, context, detail) {
+        super(`${context}: ${reason}: ${detail}`);
+        this.reason = reason;
+        this.context = context;
+    }
+}
+export class CursorProtocolDriftError extends Error {
+    context;
+    field;
+    name = "CursorProtocolDriftError";
+    code = "CURSOR_PROTOCOL_DRIFT";
+    constructor(context, field, detail = "unsupported protobuf field or variant") {
+        super(`${context}: field ${field}: ${detail}`);
+        this.context = context;
+        this.field = field;
+    }
+}
+export function unreachableVariant(value, context) {
+    void value;
+    throw new CursorProtocolDriftError(context, 0, "unsupported internal variant");
+}

package/dist/providers/cursor/proto/exec-control.d.ts

@@ -0,0 +1,20 @@
+export type ExecClientControl = {
+    readonly kind: "stream-close";
+    readonly id: number;
+} | {
+    readonly kind: "throw";
+    readonly id: number;
+    readonly error: string;
+    readonly stackTrace?: string;
+} | {
+    readonly kind: "heartbeat";
+    readonly id: number;
+};
+export type ExecServerControl = {
+    readonly kind: "abort";
+    readonly id: number;
+};
+export declare function decodeExecClientControl(bytes: Uint8Array): ExecClientControl;
+export declare function encodeExecClientControl(control: ExecClientControl): Uint8Array;
+export declare function decodeExecServerControl(bytes: Uint8Array): ExecServerControl;
+export declare function encodeExecServerControl(control: ExecServerControl): Uint8Array;

package/dist/providers/cursor/proto/exec-control.js

@@ -0,0 +1,54 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto exec control fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, encodeInt32Field, encodeStringField, } from "../proto-wire";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { oneofField, optionalString, optionalUint32 } from "./fields";
+function controlId(bytes, context) {
+    const fields = decodeFieldsStrict(bytes, { context });
+    return optionalUint32(fields, { context, field: 1, wire: 0 }) ?? 0;
+}
+export function decodeExecClientControl(bytes) {
+    const context = "ExecClientControlMessage";
+    const fields = decodeFieldsStrict(bytes, { context });
+    const message = oneofField(fields, [1, 2, 3], context);
+    if (message.field === 1)
+        return { kind: "stream-close", id: controlId(message.bytes, "ExecClientStreamClose") };
+    if (message.field === 3)
+        return { kind: "heartbeat", id: controlId(message.bytes, "ExecClientHeartbeat") };
+    if (message.field === 2) {
+        const itemContext = "ExecClientThrow";
+        const item = decodeFieldsStrict(message.bytes, { context: itemContext });
+        const stackTrace = optionalString(item, { context: itemContext, field: 3, wire: 2 });
+        return {
+            kind: "throw",
+            id: optionalUint32(item, { context: itemContext, field: 1, wire: 0 }) ?? 0,
+            error: optionalString(item, { context: itemContext, field: 2, wire: 2 }) ?? "",
+            ...(stackTrace === undefined ? {} : { stackTrace }),
+        };
+    }
+    throw new CursorProtocolDriftError(context, message.field);
+}
+export function encodeExecClientControl(control) {
+    switch (control.kind) {
+        case "stream-close":
+            return encodeBytesField(1, encodeInt32Field(1, control.id));
+        case "throw":
+            return encodeBytesField(2, concatBytes([
+                encodeInt32Field(1, control.id),
+                encodeStringField(2, control.error),
+                ...(control.stackTrace === undefined ? [] : [encodeStringField(3, control.stackTrace)]),
+            ]));
+        case "heartbeat":
+            return encodeBytesField(3, encodeInt32Field(1, control.id));
+        default:
+            return unreachableVariant(control, "ExecClientControlMessage");
+    }
+}
+export function decodeExecServerControl(bytes) {
+    const context = "ExecServerControlMessage";
+    const message = oneofField(decodeFieldsStrict(bytes, { context }), [1], context);
+    return { kind: "abort", id: controlId(message.bytes, "ExecServerAbort") };
+}
+export function encodeExecServerControl(control) {
+    return encodeBytesField(1, encodeInt32Field(1, control.id));
+}

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

@@ -0,0 +1,47 @@
+import { type McpArgs, type McpResult } from "./mcp";
+import { type RequestContextResult } from "./request-context";
+export type { RequestContext, RequestContextResult } from "./request-context";
+type ExecIdentity = {
+    readonly id: number;
+    readonly execId: string;
+};
+export type ExecServerMessage = ExecIdentity & ({
+    readonly kind: "metadata";
+    readonly acceptHookAdditionalContexts: boolean;
+} | {
+    readonly kind: "request-context-args";
+    readonly notesSessionId?: string;
+    readonly workspaceId?: string;
+} | {
+    readonly kind: "mcp-args";
+    readonly args: McpArgs;
+} | {
+    readonly kind: "native";
+    readonly operation: ExecNativeOperation;
+    readonly field: number;
+    readonly payload: Uint8Array;
+    readonly spanContext?: Uint8Array;
+});
+export type ExecClientMessage = {
+    readonly kind: "request-context-result";
+    readonly id: number;
+    readonly execId: string;
+    readonly result: RequestContextResult;
+} | {
+    readonly kind: "mcp-result";
+    readonly id: number;
+    readonly execId: string;
+    readonly result: McpResult;
+} | {
+    readonly kind: "native";
+    readonly operation: ExecNativeOperation;
+    readonly field: number;
+    readonly id: number;
+    readonly execId: string;
+    readonly payload: Uint8Array;
+};
+export type ExecNativeOperation = "shell" | "write" | "delete" | "grep" | "read" | "ls" | "diagnostics" | "shell-stream" | "background-shell-spawn" | "list-mcp-resources" | "read-mcp-resource" | "fetch" | "record-screen" | "computer-use" | "write-shell-stdin";
+export declare function decodeExecServerMessage(bytes: Uint8Array): ExecServerMessage;
+export declare function encodeExecServerMessage(message: ExecServerMessage): Uint8Array;
+export declare function decodeExecClientMessage(bytes: Uint8Array): ExecClientMessage;
+export declare function encodeExecClientMessage(message: ExecClientMessage): Uint8Array;

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

@@ -0,0 +1,154 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto exec/request-context fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBoolField, encodeBytesField, encodeInt32Field, encodeStringField, } from "../proto-wire";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { assertKnownFields, oneofField, optionalBool, optionalField, optionalString, optionalUint32, } from "./fields";
+import { decodeMcpArgs, decodeMcpResult, encodeMcpArgs, encodeMcpResult, } from "./mcp";
+import { decodeRequestContextResult, encodeRequestContextResult, } from "./request-context";
+const NATIVE_EXEC_FIELDS = {
+    2: "shell",
+    3: "write",
+    4: "delete",
+    5: "grep",
+    7: "read",
+    8: "ls",
+    9: "diagnostics",
+    14: "shell-stream",
+    16: "background-shell-spawn",
+    17: "list-mcp-resources",
+    18: "read-mcp-resource",
+    20: "fetch",
+    21: "record-screen",
+    22: "computer-use",
+    23: "write-shell-stdin",
+};
+const EXEC_MESSAGE_FIELDS = [2, 3, 4, 5, 7, 8, 9, 10, 11, 14, 16, 17, 18, 20, 21, 22, 23];
+function execIdentity(fields, context) {
+    const id = optionalUint32(fields, { context, field: 1, wire: 0 }) ?? 0;
+    const execId = optionalString(fields, { context, field: 15, wire: 2 }) ?? "";
+    return { id, execId };
+}
+export function decodeExecServerMessage(bytes) {
+    const context = "ExecServerMessage";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, ...EXEC_MESSAGE_FIELDS, 15, 19, 55], context);
+    const identity = execIdentity(fields, context);
+    const acceptHookAdditionalContexts = optionalBool(fields, { context, field: 55, wire: 0 });
+    const span = optionalField(fields, { context, field: 19, wire: 2 });
+    const variantCount = fields.filter((field) => EXEC_MESSAGE_FIELDS.includes(field.field)).length;
+    if (variantCount === 0 && acceptHookAdditionalContexts !== undefined) {
+        return { kind: "metadata", ...identity, acceptHookAdditionalContexts };
+    }
+    const message = oneofField(fields, EXEC_MESSAGE_FIELDS, context);
+    switch (message.field) {
+        case 10: {
+            const argsContext = "RequestContextArgs";
+            const args = decodeFieldsStrict(message.bytes, { context: argsContext });
+            assertKnownFields(args, [2, 3], argsContext);
+            const notesSessionId = optionalString(args, { context: argsContext, field: 2, wire: 2 });
+            const workspaceId = optionalString(args, { context: argsContext, field: 3, wire: 2 });
+            return {
+                kind: "request-context-args",
+                ...identity,
+                ...(notesSessionId === undefined ? {} : { notesSessionId }),
+                ...(workspaceId === undefined ? {} : { workspaceId }),
+            };
+        }
+        case 11:
+            return { kind: "mcp-args", ...identity, args: decodeMcpArgs(message.bytes) };
+        default: {
+            const operation = NATIVE_EXEC_FIELDS[message.field];
+            if (operation === undefined)
+                throw new CursorProtocolDriftError(context, message.field);
+            return {
+                kind: "native",
+                operation,
+                field: message.field,
+                ...identity,
+                payload: message.bytes,
+                ...(span === undefined ? {} : { spanContext: span.bytes }),
+            };
+        }
+    }
+}
+export function encodeExecServerMessage(message) {
+    const id = encodeInt32Field(1, message.id);
+    const execId = encodeStringField(15, message.execId);
+    switch (message.kind) {
+        case "metadata":
+            return concatBytes([id, execId, encodeBoolField(55, message.acceptHookAdditionalContexts)]);
+        case "request-context-args":
+            return concatBytes([
+                id,
+                encodeBytesField(10, concatBytes([
+                    ...(message.notesSessionId === undefined
+                        ? []
+                        : [encodeStringField(2, message.notesSessionId)]),
+                    ...(message.workspaceId === undefined
+                        ? []
+                        : [encodeStringField(3, message.workspaceId)]),
+                ])),
+                execId,
+            ]);
+        case "mcp-args": {
+            const payload = encodeBytesField(11, encodeMcpArgs(message.args));
+            return concatBytes([id, payload, execId]);
+        }
+        case "native":
+            return concatBytes([
+                id,
+                encodeBytesField(message.field, message.payload),
+                execId,
+                ...(message.spanContext === undefined ? [] : [encodeBytesField(19, message.spanContext)]),
+            ]);
+        default:
+            return unreachableVariant(message, "ExecServerMessage");
+    }
+}
+export function decodeExecClientMessage(bytes) {
+    const context = "ExecClientMessage";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, ...EXEC_MESSAGE_FIELDS, 15], context);
+    const identity = execIdentity(fields, context);
+    const message = oneofField(fields, EXEC_MESSAGE_FIELDS, context);
+    switch (message.field) {
+        case 10:
+            return {
+                kind: "request-context-result",
+                ...identity,
+                result: decodeRequestContextResult(message.bytes),
+            };
+        case 11:
+            return { kind: "mcp-result", ...identity, result: decodeMcpResult(message.bytes) };
+        default: {
+            const operation = NATIVE_EXEC_FIELDS[message.field];
+            if (operation === undefined)
+                throw new CursorProtocolDriftError(context, message.field);
+            return {
+                kind: "native",
+                operation,
+                field: message.field,
+                ...identity,
+                payload: message.bytes,
+            };
+        }
+    }
+}
+export function encodeExecClientMessage(message) {
+    const id = encodeInt32Field(1, message.id);
+    const execId = encodeStringField(15, message.execId);
+    switch (message.kind) {
+        case "request-context-result":
+            return concatBytes([
+                id,
+                encodeBytesField(10, encodeRequestContextResult(message.result)),
+                execId,
+            ]);
+        case "mcp-result":
+            return concatBytes([id, encodeBytesField(11, encodeMcpResult(message.result)), execId]);
+        case "native":
+            return concatBytes([id, encodeBytesField(message.field, message.payload), execId]);
+        default:
+            return unreachableVariant(message, "ExecClientMessage");
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { ProtoField } from "../proto-wire";
+export type FieldSpec = {
+    readonly context: string;
+    readonly field: number;
+    readonly wire: number;
+};
+export type ProtoDriftMetadata = {
+    readonly unknownFields: readonly ProtoField[];
+    readonly stranding: boolean;
+};
+export declare function assertKnownFields(fields: readonly ProtoField[], allowed: readonly number[], context: string): void;
+export declare function collectDriftMetadata(fields: readonly ProtoField[], allowed: readonly number[], stranding?: boolean): ProtoDriftMetadata | undefined;
+export declare function encodeDriftFields(drift: ProtoDriftMetadata | undefined): Uint8Array;
+export declare function repeatedFields(fields: readonly ProtoField[], spec: FieldSpec): readonly ProtoField[];
+export declare function optionalField(fields: readonly ProtoField[], spec: FieldSpec): ProtoField | undefined;
+export declare function requiredField(fields: readonly ProtoField[], spec: FieldSpec): ProtoField;
+export declare function oneofField(fields: readonly ProtoField[], allowed: readonly number[], context: string): ProtoField;
+export declare function requiredString(fields: readonly ProtoField[], spec: FieldSpec): string;
+export declare function optionalString(fields: readonly ProtoField[], spec: FieldSpec): string | undefined;
+export declare function requiredUint32(fields: readonly ProtoField[], spec: FieldSpec): number;
+export declare function optionalUint32(fields: readonly ProtoField[], spec: FieldSpec): number | undefined;
+export declare function optionalBool(fields: readonly ProtoField[], spec: FieldSpec): boolean | undefined;

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

@@ -0,0 +1,97 @@
+import { decodeUtf8Strict, decodeVarintNumberStrict } from "../proto-wire";
+import { CursorProtocolDriftError, CursorProtocolError } from "./errors";
+import { encodeUnknownField } from "./unknown-field";
+function verifyWire(entry, spec) {
+    if (entry.wire !== spec.wire) {
+        throw new CursorProtocolError("wrong-wire", spec.context, `field ${spec.field} expected wire ${spec.wire}, received ${entry.wire}`);
+    }
+    return entry;
+}
+export function assertKnownFields(fields, allowed, context) {
+    const unknown = fields.find((entry) => !allowed.includes(entry.field));
+    if (unknown !== undefined) {
+        throw new CursorProtocolDriftError(context, unknown.field);
+    }
+}
+export function collectDriftMetadata(fields, allowed, stranding = false) {
+    const unknownFields = fields.filter((entry) => !allowed.includes(entry.field));
+    return unknownFields.length === 0 ? undefined : { unknownFields, stranding };
+}
+export function encodeDriftFields(drift) {
+    if (drift === undefined) {
+        return new Uint8Array();
+    }
+    const encoded = drift.unknownFields.map((entry) => encodeUnknownField(entry.field, entry.wire, entry.bytes));
+    let length = 0;
+    for (const field of encoded)
+        length += field.length;
+    const output = new Uint8Array(length);
+    let offset = 0;
+    for (const field of encoded) {
+        output.set(field, offset);
+        offset += field.length;
+    }
+    return output;
+}
+export function repeatedFields(fields, spec) {
+    const matches = [];
+    for (const entry of fields) {
+        if (entry.field === spec.field) {
+            matches.push(verifyWire(entry, spec));
+        }
+    }
+    return matches;
+}
+export function optionalField(fields, spec) {
+    const matches = repeatedFields(fields, spec);
+    if (matches.length > 1) {
+        throw new CursorProtocolError("malformed", spec.context, `field ${spec.field} appears more than once`);
+    }
+    return matches.at(0);
+}
+export function requiredField(fields, spec) {
+    const entry = optionalField(fields, spec);
+    if (entry === undefined) {
+        throw new CursorProtocolError("malformed", spec.context, `required field ${spec.field} is absent`);
+    }
+    return entry;
+}
+export function oneofField(fields, allowed, context) {
+    const matches = fields.filter((entry) => allowed.includes(entry.field));
+    if (matches.length !== 1) {
+        throw new CursorProtocolError("malformed", context, `expected one variant, received ${matches.length}`);
+    }
+    const entry = matches.at(0);
+    if (entry === undefined) {
+        throw new CursorProtocolError("malformed", context, "oneof variant is absent");
+    }
+    return verifyWire(entry, { context, field: entry.field, wire: 2 });
+}
+export function requiredString(fields, spec) {
+    return decodeUtf8Strict(requiredField(fields, spec).bytes, `${spec.context} field ${spec.field}`);
+}
+export function optionalString(fields, spec) {
+    const entry = optionalField(fields, spec);
+    return entry === undefined
+        ? undefined
+        : decodeUtf8Strict(entry.bytes, `${spec.context} field ${spec.field}`);
+}
+export function requiredUint32(fields, spec) {
+    return decodeVarintNumberStrict(requiredField(fields, spec).bytes, `${spec.context} field ${spec.field}`);
+}
+export function optionalUint32(fields, spec) {
+    const entry = optionalField(fields, spec);
+    return entry === undefined
+        ? undefined
+        : decodeVarintNumberStrict(entry.bytes, `${spec.context} field ${spec.field}`);
+}
+export function optionalBool(fields, spec) {
+    const value = optionalUint32(fields, spec);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value !== 0 && value !== 1) {
+        throw new CursorProtocolError("malformed", spec.context, `field ${spec.field} is not boolean`);
+    }
+    return value === 1;
+}

package/dist/providers/cursor/proto/interaction-query.d.ts

@@ -0,0 +1,15 @@
+export type InteractionKind = "web-search" | "ask-question" | "switch-mode" | "exa-search" | "exa-fetch" | "create-plan" | "setup-vm" | "field-9";
+export type InteractionQuery = {
+    readonly kind: InteractionKind;
+    readonly id: number;
+    readonly payload: Uint8Array;
+};
+export type InteractionResponse = {
+    readonly kind: InteractionKind;
+    readonly id: number;
+    readonly payload: Uint8Array;
+};
+export declare function decodeInteractionQuery(bytes: Uint8Array): InteractionQuery;
+export declare function encodeInteractionQuery(query: InteractionQuery): Uint8Array;
+export declare function decodeInteractionResponse(bytes: Uint8Array): InteractionResponse;
+export declare function encodeInteractionResponse(response: InteractionResponse): Uint8Array;

package/dist/providers/cursor/proto/interaction-query.js

@@ -0,0 +1,79 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto InteractionQuery/Response. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, encodeInt32Field } from "../proto-wire";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { assertKnownFields, oneofField, requiredUint32 } from "./fields";
+function kindForField(field, context) {
+    switch (field) {
+        case 2:
+            return "web-search";
+        case 3:
+            return "ask-question";
+        case 4:
+            return "switch-mode";
+        case 5:
+            return "exa-search";
+        case 6:
+            return "exa-fetch";
+        case 7:
+            return "create-plan";
+        case 8:
+            return "setup-vm";
+        case 9:
+            return "field-9";
+        default:
+            throw new CursorProtocolDriftError(context, field);
+    }
+}
+function fieldForKind(kind) {
+    switch (kind) {
+        case "web-search":
+            return 2;
+        case "ask-question":
+            return 3;
+        case "switch-mode":
+            return 4;
+        case "exa-search":
+            return 5;
+        case "exa-fetch":
+            return 6;
+        case "create-plan":
+            return 7;
+        case "setup-vm":
+            return 8;
+        case "field-9":
+            return 9;
+        default:
+            return unreachableVariant(kind, "InteractionKind");
+    }
+}
+function decodeInteraction(bytes, context) {
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5, 6, 7, 8, 9], context);
+    const message = oneofField(fields, [2, 3, 4, 5, 6, 7, 8, 9], context);
+    const kind = kindForField(message.field, context);
+    decodeFieldsStrict(message.bytes, { context: `${context}.${kind}` });
+    return {
+        kind,
+        id: requiredUint32(fields, { context, field: 1, wire: 0 }),
+        payload: message.bytes,
+    };
+}
+function encodeInteraction(message) {
+    return concatBytes([
+        encodeInt32Field(1, message.id),
+        encodeBytesField(fieldForKind(message.kind), message.payload),
+    ]);
+}
+export function decodeInteractionQuery(bytes) {
+    return decodeInteraction(bytes, "InteractionQuery");
+}
+export function encodeInteractionQuery(query) {
+    return encodeInteraction(query);
+}
+export function decodeInteractionResponse(bytes) {
+    return decodeInteraction(bytes, "InteractionResponse");
+}
+export function encodeInteractionResponse(response) {
+    return encodeInteraction(response);
+}

package/dist/providers/cursor/proto/interaction-tool-update.d.ts

@@ -0,0 +1,10 @@
+import { type McpArgs, type McpToolResult } from "./mcp";
+export type ToolUpdate = {
+    readonly callId: string;
+    readonly modelCallId: string;
+    readonly args: McpArgs;
+    readonly result?: McpToolResult;
+    readonly rawPayload?: Uint8Array;
+};
+export declare function decodeToolUpdate(bytes: Uint8Array, context: string): ToolUpdate;
+export declare function encodeToolUpdate(update: ToolUpdate): Uint8Array;

package/dist/providers/cursor/proto/interaction-tool-update.js

@@ -0,0 +1,58 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto InteractionUpdate fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, encodeStringField } from "../proto-wire";
+import { assertKnownFields, oneofField, optionalField, requiredField, requiredString, } from "./fields";
+import { decodeMcpArgs, decodeMcpToolResult, encodeMcpArgs, encodeMcpToolResult, } from "./mcp";
+function opaqueToolUpdate(bytes) {
+    return {
+        callId: "",
+        modelCallId: "",
+        args: { name: "", args: {}, toolCallId: "", providerIdentifier: "", toolName: "" },
+        rawPayload: bytes,
+    };
+}
+export function decodeToolUpdate(bytes, context) {
+    if (bytes.length === 0) {
+        return opaqueToolUpdate(bytes);
+    }
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3], context);
+    const callIdField = optionalField(fields, { context, field: 1, wire: 2 });
+    const modelCallIdField = optionalField(fields, { context, field: 3, wire: 2 });
+    if (callIdField === undefined || modelCallIdField === undefined) {
+        return opaqueToolUpdate(bytes);
+    }
+    const toolCallContext = "ToolCall";
+    const toolCall = decodeFieldsStrict(requiredField(fields, { context, field: 2, wire: 2 }).bytes, {
+        context: toolCallContext,
+    });
+    assertKnownFields(toolCall, [15], toolCallContext);
+    const mcpContext = "McpToolCall";
+    const mcp = decodeFieldsStrict(oneofField(toolCall, [15], toolCallContext).bytes, {
+        context: mcpContext,
+    });
+    assertKnownFields(mcp, [1, 2], mcpContext);
+    const result = optionalField(mcp, { context: mcpContext, field: 2, wire: 2 });
+    return {
+        callId: requiredString(fields, { context, field: 1, wire: 2 }),
+        modelCallId: requiredString(fields, { context, field: 3, wire: 2 }),
+        args: decodeMcpArgs(requiredField(mcp, { context: mcpContext, field: 1, wire: 2 }).bytes),
+        ...(result === undefined ? {} : { result: decodeMcpToolResult(result.bytes) }),
+    };
+}
+export function encodeToolUpdate(update) {
+    if (update.rawPayload !== undefined) {
+        return update.rawPayload;
+    }
+    const mcp = concatBytes([
+        encodeBytesField(1, encodeMcpArgs(update.args)),
+        ...(update.result === undefined
+            ? []
+            : [encodeBytesField(2, encodeMcpToolResult(update.result))]),
+    ]);
+    return concatBytes([
+        encodeStringField(1, update.callId),
+        encodeBytesField(2, encodeBytesField(15, mcp)),
+        encodeStringField(3, update.modelCallId),
+    ]);
+}

package/dist/providers/cursor/proto/interaction-turn-ended.d.ts

@@ -0,0 +1,6 @@
+export type TurnEndedUpdate = {
+    readonly kind: "turn-ended";
+    readonly payload?: Uint8Array;
+};
+export declare function decodeTurnEndedUpdate(bytes: Uint8Array): TurnEndedUpdate;
+export declare function encodeTurnEndedUpdate(update: TurnEndedUpdate): Uint8Array;

package/dist/providers/cursor/proto/interaction-turn-ended.js

@@ -0,0 +1,18 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto TurnEndedUpdate. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { decodeFieldsStrict } from "../proto-wire";
+import { assertKnownFields, optionalField } from "./fields";
+export function decodeTurnEndedUpdate(bytes) {
+    const context = "TurnEndedUpdate";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5], context);
+    optionalField(fields, { context, field: 1, wire: 0 });
+    optionalField(fields, { context, field: 2, wire: 0 });
+    optionalField(fields, { context, field: 3, wire: 0 });
+    optionalField(fields, { context, field: 4, wire: 0 });
+    optionalField(fields, { context, field: 5, wire: 0 });
+    return { kind: "turn-ended", payload: bytes };
+}
+export function encodeTurnEndedUpdate(update) {
+    return update.payload ?? new Uint8Array();
+}