opencode-ext-connector 0.3.0

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

@@ -0,0 +1,65 @@
+import { type ProtoDriftMetadata } from "./fields";
+import { type ToolUpdate } from "./interaction-tool-update";
+import { decodeTurnEndedUpdate } from "./interaction-turn-ended";
+export { decodeInteractionQuery, decodeInteractionResponse, encodeInteractionQuery, encodeInteractionResponse, type InteractionKind, type InteractionQuery, type InteractionResponse, } from "./interaction-query";
+type SemanticInteractionUpdateBody = {
+    readonly kind: "text-delta";
+    readonly text: string;
+} | ({
+    readonly kind: "tool-call-started";
+} & ToolUpdate) | ({
+    readonly kind: "tool-call-completed";
+} & ToolUpdate) | {
+    readonly kind: "thinking-delta";
+    readonly text: string;
+} | {
+    readonly kind: "thinking-completed";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "user-message-appended";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "partial-tool-call";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "token-delta";
+    readonly tokens: number;
+} | {
+    readonly kind: "summary";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "summary-started";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "summary-completed";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "shell-output-delta";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "heartbeat";
+} | ReturnType<typeof decodeTurnEndedUpdate> | {
+    readonly kind: "tool-call-delta";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "step-started";
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: "step-completed";
+    readonly payload: Uint8Array;
+};
+export type Field25Telemetry = {
+    readonly placement: "before-semantic" | "after-semantic";
+    readonly payload: Uint8Array;
+};
+type SemanticInteractionUpdate = SemanticInteractionUpdateBody & {
+    readonly drift?: ProtoDriftMetadata;
+    readonly field25Telemetry?: Field25Telemetry;
+};
+export type InteractionUpdate = SemanticInteractionUpdate | {
+    readonly kind: "field-25";
+    readonly payload: Uint8Array;
+    readonly drift?: ProtoDriftMetadata;
+};
+export declare function decodeInteractionUpdate(bytes: Uint8Array): InteractionUpdate;
+export declare function encodeInteractionUpdate(update: InteractionUpdate): Uint8Array;

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

@@ -0,0 +1,185 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto InteractionUpdate fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, encodeInt32Field, encodeStringField, } from "../proto-wire";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { assertKnownFields, collectDriftMetadata, encodeDriftFields, oneofField, optionalField, optionalString, optionalUint32, } from "./fields";
+import { decodeToolUpdate, encodeToolUpdate } from "./interaction-tool-update";
+import { decodeTurnEndedUpdate, encodeTurnEndedUpdate } from "./interaction-turn-ended";
+import { encodeUnknownField } from "./unknown-field";
+export { decodeInteractionQuery, decodeInteractionResponse, encodeInteractionQuery, encodeInteractionResponse, } from "./interaction-query";
+const SEMANTIC_FIELDS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
+const KNOWN_FIELDS = [...SEMANTIC_FIELDS, 25];
+function decodeTextUpdate(bytes, context) {
+    const fields = decodeFieldsStrict(bytes, { context });
+    const drift = collectDriftMetadata(fields, [1]);
+    return {
+        text: optionalString(fields, { context, field: 1, wire: 2 }) ?? "",
+        ...(drift === undefined ? {} : { drift }),
+    };
+}
+function encodeTextUpdate(field, update) {
+    return encodeBytesField(field, concatBytes([
+        ...(update.text === "" ? [] : [encodeStringField(1, update.text)]),
+        encodeDriftFields(update.drift),
+    ]));
+}
+function assertEmptyUpdate(bytes, context) {
+    assertKnownFields(decodeFieldsStrict(bytes, { context }), [], context);
+}
+function decodeSemanticInteractionUpdate(update) {
+    switch (update.field) {
+        case 1:
+            return { kind: "text-delta", ...decodeTextUpdate(update.bytes, "TextDeltaUpdate") };
+        case 2:
+            return {
+                kind: "tool-call-started",
+                ...decodeToolUpdate(update.bytes, "ToolCallStartedUpdate"),
+            };
+        case 3:
+            return {
+                kind: "tool-call-completed",
+                ...decodeToolUpdate(update.bytes, "ToolCallCompletedUpdate"),
+            };
+        case 4:
+            return { kind: "thinking-delta", ...decodeTextUpdate(update.bytes, "ThinkingDeltaUpdate") };
+        case 5:
+            return { kind: "thinking-completed", payload: update.bytes };
+        case 6:
+            return { kind: "user-message-appended", payload: update.bytes };
+        case 7:
+            return { kind: "partial-tool-call", payload: update.bytes };
+        case 8: {
+            const tokenContext = "TokenDeltaUpdate";
+            const tokenFields = decodeFieldsStrict(update.bytes, { context: tokenContext });
+            assertKnownFields(tokenFields, [1], tokenContext);
+            return {
+                kind: "token-delta",
+                tokens: optionalUint32(tokenFields, { context: tokenContext, field: 1, wire: 0 }) ?? 0,
+            };
+        }
+        case 9:
+            return { kind: "summary", payload: update.bytes };
+        case 10:
+            return { kind: "summary-started", payload: update.bytes };
+        case 11:
+            return { kind: "summary-completed", payload: update.bytes };
+        case 12:
+            return { kind: "shell-output-delta", payload: update.bytes };
+        case 13:
+            assertEmptyUpdate(update.bytes, "HeartbeatUpdate");
+            return { kind: "heartbeat" };
+        case 14:
+            return decodeTurnEndedUpdate(update.bytes);
+        case 15:
+            return { kind: "tool-call-delta", payload: update.bytes };
+        case 16:
+            return { kind: "step-started", payload: update.bytes };
+        case 17:
+            return { kind: "step-completed", payload: update.bytes };
+        default:
+            throw new CursorProtocolDriftError("InteractionUpdate", update.field);
+    }
+}
+export function decodeInteractionUpdate(bytes) {
+    const context = "InteractionUpdate";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, KNOWN_FIELDS, context);
+    const field25 = optionalField(fields, { context, field: 25, wire: 0 });
+    if (field25 !== undefined && fields.length === 1) {
+        return { kind: "field-25", payload: field25.bytes };
+    }
+    const update = oneofField(fields, SEMANTIC_FIELDS, context);
+    const semantic = decodeSemanticInteractionUpdate(update);
+    if (field25 === undefined) {
+        return semantic;
+    }
+    return {
+        ...semantic,
+        field25Telemetry: {
+            placement: fields.indexOf(field25) < fields.indexOf(update) ? "before-semantic" : "after-semantic",
+            payload: field25.bytes,
+        },
+    };
+}
+function encodeSemanticInteractionUpdate(update) {
+    switch (update.kind) {
+        case "text-delta":
+            return encodeTextUpdate(1, update);
+        case "tool-call-started":
+            return encodeBytesField(2, encodeToolUpdate(update));
+        case "tool-call-completed":
+            return encodeBytesField(3, encodeToolUpdate(update));
+        case "thinking-delta":
+            return encodeTextUpdate(4, update);
+        case "thinking-completed":
+            return encodeBytesField(5, update.payload);
+        case "user-message-appended":
+            return encodeBytesField(6, update.payload);
+        case "partial-tool-call":
+            return encodeBytesField(7, update.payload);
+        case "token-delta":
+            return encodeBytesField(8, update.tokens === 0 ? new Uint8Array() : encodeInt32Field(1, update.tokens));
+        case "summary":
+            return encodeBytesField(9, update.payload);
+        case "summary-started":
+            return encodeBytesField(10, update.payload);
+        case "summary-completed":
+            return encodeBytesField(11, update.payload);
+        case "shell-output-delta":
+            return encodeBytesField(12, update.payload);
+        case "heartbeat":
+            return encodeBytesField(13, new Uint8Array());
+        case "turn-ended":
+            return encodeBytesField(14, encodeTurnEndedUpdate(update));
+        case "tool-call-delta":
+            return encodeBytesField(15, update.payload);
+        case "step-started":
+            return encodeBytesField(16, update.payload);
+        case "step-completed":
+            return encodeBytesField(17, update.payload);
+        default:
+            return unreachableVariant(update, "SemanticInteractionUpdate");
+    }
+}
+function encodeSemanticWithTelemetry(update) {
+    const semantic = encodeSemanticInteractionUpdate(update);
+    const telemetry = update.field25Telemetry;
+    if (telemetry === undefined) {
+        return semantic;
+    }
+    const field25 = encodeUnknownField(25, 0, telemetry.payload);
+    switch (telemetry.placement) {
+        case "before-semantic":
+            return concatBytes([field25, semantic]);
+        case "after-semantic":
+            return concatBytes([semantic, field25]);
+        default:
+            return unreachableVariant(telemetry.placement, "Field25TelemetryPlacement");
+    }
+}
+export function encodeInteractionUpdate(update) {
+    switch (update.kind) {
+        case "field-25":
+            return encodeUnknownField(25, 0, update.payload);
+        case "text-delta":
+        case "tool-call-started":
+        case "tool-call-completed":
+        case "thinking-delta":
+        case "thinking-completed":
+        case "user-message-appended":
+        case "partial-tool-call":
+        case "token-delta":
+        case "summary":
+        case "summary-started":
+        case "summary-completed":
+        case "shell-output-delta":
+        case "heartbeat":
+        case "turn-ended":
+        case "tool-call-delta":
+        case "step-started":
+        case "step-completed":
+            return encodeSemanticWithTelemetry(update);
+        default:
+            return unreachableVariant(update, "InteractionUpdate");
+    }
+}

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

@@ -0,0 +1,25 @@
+export type KvServerMessage = {
+    readonly kind: "get-blob";
+    readonly id: number;
+    readonly blobId: Uint8Array;
+    readonly spanContext?: Uint8Array;
+} | {
+    readonly kind: "set-blob";
+    readonly id: number;
+    readonly blobId: Uint8Array;
+    readonly blobData: Uint8Array;
+    readonly spanContext?: Uint8Array;
+};
+export type KvClientMessage = {
+    readonly kind: "get-blob-result";
+    readonly id: number;
+    readonly blobData?: Uint8Array;
+} | {
+    readonly kind: "set-blob-result";
+    readonly id: number;
+    readonly error?: string;
+};
+export declare function decodeKvServerMessage(bytes: Uint8Array): KvServerMessage;
+export declare function encodeKvServerMessage(message: KvServerMessage): Uint8Array;
+export declare function decodeKvClientMessage(bytes: Uint8Array): KvClientMessage;
+export declare function encodeKvClientMessage(message: KvClientMessage): Uint8Array;

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

@@ -0,0 +1,109 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto KV blob messages. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, encodeBytesField, encodeInt32Field, encodeStringField, } from "../proto-wire";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { assertKnownFields, oneofField, optionalField, optionalUint32, requiredField, requiredString, requiredUint32, } from "./fields";
+export function decodeKvServerMessage(bytes) {
+    const context = "KvServerMessage";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4], context);
+    const id = optionalUint32(fields, { context, field: 1, wire: 0 }) ?? 0;
+    const span = optionalField(fields, { context, field: 4, wire: 2 });
+    const message = oneofField(fields, [2, 3], context);
+    const nestedContext = message.field === 2 ? "GetBlobArgs" : "SetBlobArgs";
+    const nested = decodeFieldsStrict(message.bytes, { context: nestedContext });
+    switch (message.field) {
+        case 2:
+            assertKnownFields(nested, [1], nestedContext);
+            return {
+                kind: "get-blob",
+                id,
+                blobId: requiredField(nested, { context: nestedContext, field: 1, wire: 2 }).bytes,
+                ...(span === undefined ? {} : { spanContext: span.bytes }),
+            };
+        case 3:
+            assertKnownFields(nested, [1, 2], nestedContext);
+            return {
+                kind: "set-blob",
+                id,
+                blobId: requiredField(nested, { context: nestedContext, field: 1, wire: 2 }).bytes,
+                blobData: requiredField(nested, { context: nestedContext, field: 2, wire: 2 }).bytes,
+                ...(span === undefined ? {} : { spanContext: span.bytes }),
+            };
+        default:
+            throw new CursorProtocolDriftError(context, message.field);
+    }
+}
+export function encodeKvServerMessage(message) {
+    switch (message.kind) {
+        case "get-blob":
+            return concatBytes([
+                encodeInt32Field(1, message.id),
+                encodeBytesField(2, encodeBytesField(1, message.blobId)),
+                ...(message.spanContext === undefined ? [] : [encodeBytesField(4, message.spanContext)]),
+            ]);
+        case "set-blob":
+            return concatBytes([
+                encodeInt32Field(1, message.id),
+                encodeBytesField(3, concatBytes([encodeBytesField(1, message.blobId), encodeBytesField(2, message.blobData)])),
+                ...(message.spanContext === undefined ? [] : [encodeBytesField(4, message.spanContext)]),
+            ]);
+        default:
+            return unreachableVariant(message, "KvServerMessage");
+    }
+}
+export function decodeKvClientMessage(bytes) {
+    const context = "KvClientMessage";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3], context);
+    const id = requiredUint32(fields, { context, field: 1, wire: 0 });
+    const message = oneofField(fields, [2, 3], context);
+    const nestedContext = message.field === 2 ? "GetBlobResult" : "SetBlobResult";
+    const nested = decodeFieldsStrict(message.bytes, { context: nestedContext });
+    switch (message.field) {
+        case 2: {
+            assertKnownFields(nested, [1], nestedContext);
+            const blobData = optionalField(nested, { context: nestedContext, field: 1, wire: 2 });
+            return {
+                kind: "get-blob-result",
+                id,
+                ...(blobData === undefined ? {} : { blobData: blobData.bytes }),
+            };
+        }
+        case 3: {
+            assertKnownFields(nested, [1], nestedContext);
+            const error = optionalField(nested, { context: nestedContext, field: 1, wire: 2 });
+            if (error === undefined) {
+                return { kind: "set-blob-result", id };
+            }
+            const errorContext = "Error";
+            const errorFields = decodeFieldsStrict(error.bytes, { context: errorContext });
+            assertKnownFields(errorFields, [1], errorContext);
+            return {
+                kind: "set-blob-result",
+                id,
+                error: requiredString(errorFields, { context: errorContext, field: 1, wire: 2 }),
+            };
+        }
+        default:
+            throw new CursorProtocolDriftError(context, message.field);
+    }
+}
+export function encodeKvClientMessage(message) {
+    switch (message.kind) {
+        case "get-blob-result":
+            return concatBytes([
+                encodeInt32Field(1, message.id),
+                encodeBytesField(2, message.blobData === undefined ? new Uint8Array() : encodeBytesField(1, message.blobData)),
+            ]);
+        case "set-blob-result":
+            return concatBytes([
+                encodeInt32Field(1, message.id),
+                encodeBytesField(3, message.error === undefined
+                    ? new Uint8Array()
+                    : encodeBytesField(1, encodeStringField(1, message.error))),
+            ]);
+        default:
+            return unreachableVariant(message, "KvClientMessage");
+    }
+}

package/dist/providers/cursor/proto/mcp-result.d.ts

@@ -0,0 +1,40 @@
+import { type OutputLocation } from "./output-location";
+export type { OutputLocation } from "./output-location";
+export type McpResultContent = {
+    readonly kind: "text";
+    readonly text: string;
+    readonly outputLocation?: OutputLocation;
+} | {
+    readonly kind: "image";
+    readonly data: Uint8Array;
+    readonly mimeType: string;
+};
+export type McpResult = {
+    readonly kind: "success";
+    readonly content: readonly McpResultContent[];
+    readonly isError: boolean;
+} | {
+    readonly kind: "error";
+    readonly error: string;
+} | {
+    readonly kind: "rejected";
+    readonly reason: string;
+    readonly isReadonly: boolean;
+} | {
+    readonly kind: "permission-denied";
+    readonly error: string;
+    readonly isReadonly: boolean;
+} | {
+    readonly kind: "tool-not-found";
+    readonly name: string;
+    readonly availableTools: readonly string[];
+};
+export type McpToolResult = McpResult | {
+    readonly kind: "unknown-oneof";
+    readonly field: number;
+    readonly payload: Uint8Array;
+};
+export declare function decodeMcpResult(bytes: Uint8Array): McpResult;
+export declare function encodeMcpResult(result: McpResult): Uint8Array;
+export declare function decodeMcpToolResult(bytes: Uint8Array): McpToolResult;
+export declare function encodeMcpToolResult(result: McpToolResult): Uint8Array;

package/dist/providers/cursor/proto/mcp-result.js

@@ -0,0 +1,150 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto McpResult fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { concatBytes, decodeFieldsStrict, decodeUtf8Strict, encodeBoolField, encodeBytesField, encodeStringField, } from "../proto-wire";
+import { CursorProtocolDriftError, unreachableVariant } from "./errors";
+import { assertKnownFields, oneofField, optionalBool, optionalField, repeatedFields, requiredField, requiredString, } from "./fields";
+import { decodeOutputLocation, encodeOutputLocation } from "./output-location";
+import { encodeUnknownField } from "./unknown-field";
+function decodeContent(bytes) {
+    const context = "McpToolResultContentItem";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2], context);
+    const content = oneofField(fields, [1, 2], context);
+    switch (content.field) {
+        case 1: {
+            const textContext = "McpTextContent";
+            const textFields = decodeFieldsStrict(content.bytes, { context: textContext });
+            assertKnownFields(textFields, [1, 2], textContext);
+            const outputLocation = optionalField(textFields, { context: textContext, field: 2, wire: 2 });
+            return {
+                kind: "text",
+                text: requiredString(textFields, { context: textContext, field: 1, wire: 2 }),
+                ...(outputLocation === undefined
+                    ? {}
+                    : { outputLocation: decodeOutputLocation(outputLocation.bytes) }),
+            };
+        }
+        case 2: {
+            const imageContext = "McpImageContent";
+            const imageFields = decodeFieldsStrict(content.bytes, { context: imageContext });
+            assertKnownFields(imageFields, [1, 2], imageContext);
+            return {
+                kind: "image",
+                data: requiredField(imageFields, { context: imageContext, field: 1, wire: 2 }).bytes,
+                mimeType: requiredString(imageFields, { context: imageContext, field: 2, wire: 2 }),
+            };
+        }
+        default:
+            throw new CursorProtocolDriftError(context, content.field);
+    }
+}
+function encodeContent(content) {
+    switch (content.kind) {
+        case "text":
+            return encodeBytesField(1, concatBytes([
+                encodeStringField(1, content.text),
+                ...(content.outputLocation === undefined
+                    ? []
+                    : [encodeBytesField(2, encodeOutputLocation(content.outputLocation))]),
+            ]));
+        case "image":
+            return encodeBytesField(2, concatBytes([encodeBytesField(1, content.data), encodeStringField(2, content.mimeType)]));
+        default:
+            return unreachableVariant(content, "McpToolResultContentItem");
+    }
+}
+function decodeSuccess(bytes) {
+    const context = "McpSuccess";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2], context);
+    return {
+        kind: "success",
+        content: repeatedFields(fields, { context, field: 1, wire: 2 }).map((entry) => decodeContent(entry.bytes)),
+        isError: optionalBool(fields, { context, field: 2, wire: 0 }) ?? false,
+    };
+}
+function decodeMessage(bytes, context) {
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1], context);
+    return requiredString(fields, { context, field: 1, wire: 2 });
+}
+function decodeReadonlyMessage(bytes, context) {
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2], context);
+    return {
+        message: requiredString(fields, { context, field: 1, wire: 2 }),
+        isReadonly: optionalBool(fields, { context, field: 2, wire: 0 }) ?? false,
+    };
+}
+export function decodeMcpResult(bytes) {
+    const context = "McpResult";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5], context);
+    const result = oneofField(fields, [1, 2, 3, 4, 5], context);
+    switch (result.field) {
+        case 1:
+            return decodeSuccess(result.bytes);
+        case 2:
+            return { kind: "error", error: decodeMessage(result.bytes, "McpError") };
+        case 3: {
+            const rejected = decodeReadonlyMessage(result.bytes, "McpRejected");
+            return { kind: "rejected", reason: rejected.message, isReadonly: rejected.isReadonly };
+        }
+        case 4: {
+            const denied = decodeReadonlyMessage(result.bytes, "McpPermissionDenied");
+            return { kind: "permission-denied", error: denied.message, isReadonly: denied.isReadonly };
+        }
+        case 5: {
+            const itemContext = "McpToolNotFound";
+            const itemFields = decodeFieldsStrict(result.bytes, { context: itemContext });
+            assertKnownFields(itemFields, [1, 2], itemContext);
+            return {
+                kind: "tool-not-found",
+                name: requiredString(itemFields, { context: itemContext, field: 1, wire: 2 }),
+                availableTools: repeatedFields(itemFields, { context: itemContext, field: 2, wire: 2 }).map((entry) => decodeUtf8Strict(entry.bytes, `${itemContext} field 2`)),
+            };
+        }
+        default:
+            throw new CursorProtocolDriftError(context, result.field);
+    }
+}
+export function encodeMcpResult(result) {
+    switch (result.kind) {
+        case "success":
+            return encodeBytesField(1, concatBytes([
+                ...result.content.map((content) => encodeBytesField(1, encodeContent(content))),
+                encodeBoolField(2, result.isError),
+            ]));
+        case "error":
+            return encodeBytesField(2, encodeStringField(1, result.error));
+        case "rejected":
+            return encodeBytesField(3, concatBytes([encodeStringField(1, result.reason), encodeBoolField(2, result.isReadonly)]));
+        case "permission-denied":
+            return encodeBytesField(4, concatBytes([encodeStringField(1, result.error), encodeBoolField(2, result.isReadonly)]));
+        case "tool-not-found":
+            return encodeBytesField(5, concatBytes([
+                encodeStringField(1, result.name),
+                ...result.availableTools.map((name) => encodeStringField(2, name)),
+            ]));
+        default:
+            return unreachableVariant(result, "McpResult");
+    }
+}
+export function decodeMcpToolResult(bytes) {
+    const context = "McpToolResult";
+    const fields = decodeFieldsStrict(bytes, { context });
+    const result = oneofField(fields, fields.map((field) => field.field), context);
+    if (result.field > 4) {
+        return { kind: "unknown-oneof", field: result.field, payload: result.bytes };
+    }
+    return decodeMcpResult(encodeUnknownField(result.field, 2, result.bytes));
+}
+export function encodeMcpToolResult(result) {
+    if (result.kind === "unknown-oneof") {
+        return encodeBytesField(result.field, result.payload);
+    }
+    if (result.kind === "tool-not-found") {
+        throw new CursorProtocolDriftError("McpToolResult", 5);
+    }
+    return encodeMcpResult(result);
+}

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

@@ -0,0 +1,19 @@
+export { decodeMcpResult, decodeMcpToolResult, encodeMcpResult, encodeMcpToolResult, type McpResult, type McpResultContent, type McpToolResult, type OutputLocation, } from "./mcp-result";
+export type McpToolDefinition = {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: unknown;
+    readonly providerIdentifier: string;
+    readonly toolName: string;
+};
+export type McpArgs = {
+    readonly name: string;
+    readonly args: Readonly<Record<string, unknown>>;
+    readonly toolCallId: string;
+    readonly providerIdentifier: string;
+    readonly toolName: string;
+};
+export declare function decodeMcpToolDefinition(bytes: Uint8Array): McpToolDefinition;
+export declare function encodeMcpToolDefinition(definition: McpToolDefinition): Uint8Array;
+export declare function decodeMcpArgs(bytes: Uint8Array): McpArgs;
+export declare function encodeMcpArgs(args: McpArgs): Uint8Array;

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

@@ -0,0 +1,78 @@
+// Derived from Rahularya01/pi-cursor proto/agent.proto MCP fields. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { decodeProtobufValueStrict, encodeProtobufValue } from "../proto-value";
+import { concatBytes, decodeFieldsStrict, decodeUtf8Strict, encodeBytesField, encodeStringField, } from "../proto-wire";
+import { CursorProtocolError } from "./errors";
+import { assertKnownFields, optionalField, optionalString, repeatedFields, requiredField, requiredString, } from "./fields";
+export { decodeMcpResult, decodeMcpToolResult, encodeMcpResult, encodeMcpToolResult, } from "./mcp-result";
+export function decodeMcpToolDefinition(bytes) {
+    const context = "McpToolDefinition";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5], context);
+    return {
+        name: requiredString(fields, { context, field: 1, wire: 2 }),
+        description: requiredString(fields, { context, field: 2, wire: 2 }),
+        inputSchema: decodeProtobufValueStrict(requiredField(fields, { context, field: 3, wire: 2 }).bytes),
+        providerIdentifier: requiredString(fields, { context, field: 4, wire: 2 }),
+        toolName: requiredString(fields, { context, field: 5, wire: 2 }),
+    };
+}
+export function encodeMcpToolDefinition(definition) {
+    return concatBytes([
+        encodeStringField(1, definition.name),
+        encodeStringField(2, definition.description),
+        encodeBytesField(3, encodeProtobufValue(definition.inputSchema)),
+        encodeStringField(4, definition.providerIdentifier),
+        encodeStringField(5, definition.toolName),
+    ]);
+}
+function decodeArgEntry(bytes) {
+    const context = "McpArgs.ArgsEntry";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2], context);
+    const value = optionalField(fields, { context, field: 2, wire: 2 });
+    return {
+        key: optionalString(fields, { context, field: 1, wire: 2 }) ?? "",
+        value: decodeArgValue(value?.bytes ?? new Uint8Array()),
+    };
+}
+function decodeArgValue(bytes) {
+    const first = bytes.at(0);
+    const valueTags = [0x08, 0x11, 0x1a, 0x20, 0x2a, 0x32];
+    return first !== undefined && valueTags.includes(first)
+        ? decodeProtobufValueStrict(bytes)
+        : decodeUtf8Strict(bytes, "McpArgs.ArgsEntry value");
+}
+export function decodeMcpArgs(bytes) {
+    const context = "McpArgs";
+    const fields = decodeFieldsStrict(bytes, { context });
+    assertKnownFields(fields, [1, 2, 3, 4, 5], context);
+    const args = {};
+    for (const field of repeatedFields(fields, { context, field: 2, wire: 2 })) {
+        const entry = decodeArgEntry(field.bytes);
+        if (Object.hasOwn(args, entry.key)) {
+            throw new CursorProtocolError("malformed", context, `duplicate argument ${entry.key}`);
+        }
+        args[entry.key] = entry.value;
+    }
+    return {
+        name: optionalString(fields, { context, field: 1, wire: 2 }) ?? "",
+        args,
+        toolCallId: optionalString(fields, { context, field: 3, wire: 2 }) ?? "",
+        providerIdentifier: optionalString(fields, { context, field: 4, wire: 2 }) ?? "",
+        toolName: optionalString(fields, { context, field: 5, wire: 2 }) ?? "",
+    };
+}
+export function encodeMcpArgs(args) {
+    const entries = Object.keys(args.args).map((key) => encodeBytesField(2, concatBytes([
+        ...(key === "" ? [] : [encodeStringField(1, key)]),
+        encodeBytesField(2, encodeProtobufValue(args.args[key])),
+    ])));
+    return concatBytes([
+        ...(args.name === "" ? [] : [encodeStringField(1, args.name)]),
+        ...entries,
+        ...(args.toolCallId === "" ? [] : [encodeStringField(3, args.toolCallId)]),
+        ...(args.providerIdentifier === "" ? [] : [encodeStringField(4, args.providerIdentifier)]),
+        ...(args.toolName === "" ? [] : [encodeStringField(5, args.toolName)]),
+    ]);
+}