@bastani/atomic 0.9.11-alpha.4 → 0.9.11-alpha.6

package/dist/builtin/cursor/src/proto/protobuf-codec-base64.ts

@@ -1,22 +0,0 @@
-export interface CursorImageBase64Context {
-	readonly kind: string;
-	readonly mimeType: string;
-	readonly index?: number;
-}
-
-// Cursor image protobuf serialization accepts canonical standard base64 after MIME line wrapping is removed.
-const BASE64_WHITESPACE_PATTERN = /[\t\n\f\r ]+/gu;
-const STANDARD_BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
-
-export function decodeStrictBase64ImageData(data: string, context: CursorImageBase64Context): Uint8Array {
-	const normalized = data.replace(BASE64_WHITESPACE_PATTERN, "");
-	if (normalized.length === 0 || normalized.length % 4 !== 0 || !STANDARD_BASE64_PATTERN.test(normalized)) {
-		throwInvalidBase64ImageData(context);
-	}
-	return Buffer.from(normalized, "base64");
-}
-
-function throwInvalidBase64ImageData(context: CursorImageBase64Context): never {
-	const index = context.index === undefined ? "" : ` at index ${context.index}`;
-	throw new Error(`Invalid ${context.kind} base64 image data${index} for MIME type ${context.mimeType}`);
-}

package/dist/builtin/cursor/src/proto/protobuf-codec-json.ts

@@ -1,44 +0,0 @@
-import { fromBinary, fromJson, toBinary, toJson, type JsonValue as ProtobufJsonValue } from "@bufbuild/protobuf";
-import { ValueSchema } from "@bufbuild/protobuf/wkt";
-import { parseJsonValue, type JsonObject, type JsonValue } from "../config.js";
-
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-
-export function encodeProtobufValue(value: JsonValue): Uint8Array {
-	return toBinary(ValueSchema, fromJson(ValueSchema, value as ProtobufJsonValue));
-}
-
-function encodeMcpArgValue(value: JsonValue): Uint8Array {
-	try {
-		return encodeProtobufValue(value);
-	} catch {
-		return textEncoder.encode(String(value));
-	}
-}
-
-export function encodeMcpArgsMap(args: JsonObject): Record<string, Uint8Array> {
-	const encoded: Record<string, Uint8Array> = {};
-	for (const [key, value] of Object.entries(args)) encoded[key] = encodeMcpArgValue(value);
-	return encoded;
-}
-
-function decodeMcpArgValue(value: Uint8Array): JsonValue {
-	try {
-		const decoded = toJson(ValueSchema, fromBinary(ValueSchema, value)) as ProtobufJsonValue;
-		return parseJsonValue(JSON.stringify(decoded)) ?? null;
-	} catch {
-		return textDecoder.decode(value);
-	}
-}
-
-export function decodeMcpArgsMap(args: Record<string, Uint8Array>): JsonObject {
-	const decoded: JsonObject = {};
-	for (const [key, value] of Object.entries(args)) decoded[key] = decodeMcpArgValue(value);
-	return decoded;
-}
-
-export function serializableJsonValue(value: object): JsonValue {
-	return parseJsonValue(JSON.stringify(value)) ?? {};
-}
-

package/dist/builtin/cursor/src/proto/protobuf-codec-request.ts

@@ -1,311 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
-import type { ImageContent } from "@earendil-works/pi-ai/compat";
-import { parseJsonObject, type JsonObject } from "../config.js";
-import type { CursorRunRequest, CursorToolResultContent } from "../transport.js";
-import {
-	AgentClientMessageSchema,
-	AgentConversationTurnStructureSchema,
-	AgentRunRequestSchema,
-	AssistantMessageSchema,
-	ConversationActionSchema,
-	ConversationStateStructureSchema,
-	ConversationStepSchema,
-	ConversationTurnStructureSchema,
-	McpArgsSchema,
-	McpToolCallSchema,
-	McpToolDefinitionSchema,
-	ModelDetailsSchema,
-	SelectedContextSchema,
-	SelectedImageSchema,
-	ToolCallSchema,
-	UserMessageActionSchema,
-	UserMessageSchema,
-	type ConversationStateStructure,
-	type McpToolDefinition,
-	type SelectedImage,
-	type UserMessage,
-} from "./agent_pb.js";
-import { encodeMcpArgsMap, encodeProtobufValue, serializableJsonValue } from "./protobuf-codec-json.js";
-import { decodeStrictBase64ImageData } from "./protobuf-codec-base64.js";
-import { createMcpToolCallResult } from "./protobuf-codec-wire.js";
-
-export interface ParsedAssistantTextStep {
-	readonly kind: "assistantText";
-	readonly text: string;
-}
-
-export interface ParsedToolCallStep {
-	readonly kind: "toolCall";
-	readonly toolCallId: string;
-	readonly toolName: string;
-	readonly arguments: JsonObject;
-	result?: { readonly content: string | readonly CursorToolResultContent[]; readonly isError: boolean; readonly fallbackText?: string };
-}
-
-export type ParsedTurnStep = ParsedAssistantTextStep | ParsedToolCallStep;
-
-export interface ParsedTurn {
-	readonly userText: string;
-	readonly userImages: readonly ImageContent[];
-	readonly steps: ParsedTurnStep[];
-}
-
-const CURSOR_PROTO_CLIENT_NAME = "pi";
-const textEncoder = new TextEncoder();
-export function buildMcpToolDefinitions(request: CursorRunRequest): readonly McpToolDefinition[] {
-	return (request.context.tools ?? []).map((tool) => {
-		const jsonSchema = serializableJsonValue(tool.parameters);
-		return create(McpToolDefinitionSchema, {
-			name: tool.name,
-			description: tool.description,
-			providerIdentifier: CURSOR_PROTO_CLIENT_NAME,
-			toolName: tool.name,
-			inputSchema: encodeProtobufValue(jsonSchema),
-		});
-	});
-}
-
-export function buildCursorRequest(
-	modelId: string,
-	systemPrompt: string,
-	userText: string,
-	turns: readonly ParsedTurn[],
-	conversationId: string,
-	checkpoint: Uint8Array | null,
-	existingBlobStore?: Map<string, Uint8Array>,
-	userImages: readonly ImageContent[] = [],
-): { readonly requestBytes: Uint8Array; readonly blobStore: Map<string, Uint8Array> } {
-	const blobStore = new Map<string, Uint8Array>(existingBlobStore ?? []);
-	const systemBlobId = storeAsBlob(textEncoder.encode(JSON.stringify({ role: "system", content: systemPrompt })), blobStore);
-	const selectedContextBlob = storeAsBlob(buildSelectedContextBlob([systemBlobId], CURSOR_PROTO_CLIENT_NAME), blobStore);
-	const conversationState = checkpoint
-		? fromBinary(ConversationStateStructureSchema, checkpoint)
-		: buildConversationState(turns, blobStore, systemBlobId, selectedContextBlob);
-	const userMessage = createUserMessage(userText, selectedContextBlob, userImages);
-	const action = create(ConversationActionSchema, {
-		action: { case: "userMessageAction", value: create(UserMessageActionSchema, { userMessage }) },
-	});
-	const modelDetails = create(ModelDetailsSchema, { modelId, displayModelId: modelId, displayName: modelId });
-	const runRequest = create(AgentRunRequestSchema, { conversationState, action, modelDetails, conversationId });
-	const clientMessage = create(AgentClientMessageSchema, {
-		message: { case: "runRequest", value: runRequest },
-	});
-	return { requestBytes: toBinary(AgentClientMessageSchema, clientMessage), blobStore };
-}
-
-function buildConversationState(
-	turns: readonly ParsedTurn[],
-	blobStore: Map<string, Uint8Array>,
-	systemBlobId: Uint8Array,
-	selectedContextBlob: Uint8Array,
-): ConversationStateStructure {
-	const turnBlobIds: Uint8Array[] = [];
-	for (const turn of turns) {
-		const userMessage = createUserMessage(turn.userText, selectedContextBlob, turn.userImages);
-		const userMessageBlobId = storeAsBlob(toBinary(UserMessageSchema, userMessage), blobStore);
-		const stepBlobIds = turn.steps.map((step) => storeAsBlob(buildTurnStepBytes(step), blobStore));
-		const agentTurn = create(AgentConversationTurnStructureSchema, {
-			userMessage: userMessageBlobId,
-			steps: stepBlobIds,
-			requestId: randomUUID(),
-		});
-		const turnStructure = create(ConversationTurnStructureSchema, {
-			turn: { case: "agentConversationTurn", value: agentTurn },
-		});
-		turnBlobIds.push(storeAsBlob(toBinary(ConversationTurnStructureSchema, turnStructure), blobStore));
-	}
-	return create(ConversationStateStructureSchema, {
-		rootPromptMessagesJson: [systemBlobId],
-		turns: turnBlobIds,
-		todos: [],
-		pendingToolCalls: [],
-		previousWorkspaceUris: [],
-		mode: 1,
-		fileStates: {},
-		fileStatesV2: {},
-		summaryArchives: [],
-		turnTimings: [],
-		subagentStates: {},
-		selfSummaryCount: 0,
-		readPaths: [],
-		clientName: CURSOR_PROTO_CLIENT_NAME,
-	});
-}
-
-function createUserMessage(text: string, selectedContextBlob: Uint8Array, images: readonly ImageContent[] = []): UserMessage {
-	const messageId = randomUUID();
-	const selectedImages = images.map((image, index) => createSelectedImage(image, index));
-	return create(UserMessageSchema, {
-		text,
-		messageId,
-		selectedContext: create(SelectedContextSchema, { selectedImages }),
-		mode: 1,
-		selectedContextBlob,
-		correlationId: messageId,
-	});
-}
-
-function createSelectedImage(image: ImageContent, index: number): SelectedImage {
-	const data = decodeStrictBase64ImageData(image.data, { kind: "selected image", mimeType: image.mimeType, index });
-	const hash = createHash("sha256").update(data).digest("hex").slice(0, 16);
-	return create(SelectedImageSchema, {
-		uuid: randomUUID(),
-		path: `/atomic/inline-images/${hash}-${index}.${extensionForMimeType(image.mimeType)}`,
-		mimeType: image.mimeType,
-		dataOrBlobId: { case: "data", value: data },
-	});
-}
-
-function extensionForMimeType(mimeType: string): string {
-	const normalized = mimeType.toLowerCase();
-	if (normalized === "image/jpeg" || normalized === "image/jpg") return "jpg";
-	if (normalized === "image/png") return "png";
-	if (normalized === "image/gif") return "gif";
-	if (normalized === "image/webp") return "webp";
-	return "img";
-}
-
-function buildTurnStepBytes(step: ParsedTurnStep): Uint8Array {
-	if (step.kind === "assistantText") {
-		return toBinary(ConversationStepSchema, create(ConversationStepSchema, {
-			message: { case: "assistantMessage", value: create(AssistantMessageSchema, { text: step.text }) },
-		}));
-	}
-	const toolName = step.toolName || "tool";
-	const mcpToolCall = create(McpToolCallSchema, {
-		args: create(McpArgsSchema, {
-			name: toolName,
-			args: encodeMcpArgsMap(step.arguments),
-			toolCallId: step.toolCallId,
-			providerIdentifier: CURSOR_PROTO_CLIENT_NAME,
-			toolName,
-		}),
-		...(step.result ? { result: createMcpToolCallResult(step.result.content, step.result.isError, step.result.fallbackText ?? "") } : {}),
-	});
-	return toBinary(ConversationStepSchema, create(ConversationStepSchema, {
-		message: {
-			case: "toolCall",
-			value: create(ToolCallSchema, { tool: { case: "mcpToolCall", value: mcpToolCall } }),
-		},
-	}));
-}
-
-export function parseHistoricalTurns(messages: readonly CursorRunRequest["context"]["messages"][number][]): readonly ParsedTurn[] {
-	const turns: ParsedTurn[] = [];
-	let currentTurn: { userText: string; userImages: readonly ImageContent[]; steps: ParsedTurnStep[]; toolCallById: Map<string, ParsedToolCallStep> } | undefined;
-	const ensureTurn = (): { userText: string; userImages: readonly ImageContent[]; steps: ParsedTurnStep[]; toolCallById: Map<string, ParsedToolCallStep> } => {
-		currentTurn ??= { userText: "", userImages: [], steps: [], toolCallById: new Map() };
-		return currentTurn;
-	};
-	const flushTurn = (): void => {
-		if (!currentTurn) return;
-		if (currentTurn.userText || currentTurn.userImages.length > 0 || currentTurn.steps.length > 0) {
-			turns.push({ userText: currentTurn.userText, userImages: currentTurn.userImages, steps: currentTurn.steps });
-		}
-		currentTurn = undefined;
-	};
-	for (const message of messages) {
-		if (message.role === "user") {
-			flushTurn();
-			currentTurn = { userText: textFromMessage(message), userImages: imagesFromUserMessage(message), steps: [], toolCallById: new Map() };
-		} else if (message.role === "assistant") {
-			const turn = ensureTurn();
-			for (const part of message.content) {
-				if (part.type === "text") appendAssistantTextStep(turn.steps, part.text);
-				else if (part.type === "thinking") appendAssistantTextStep(turn.steps, part.thinking);
-				else {
-					const step: ParsedToolCallStep = { kind: "toolCall", toolCallId: part.id, toolName: part.name, arguments: parseJsonObject(JSON.stringify(part.arguments)) ?? {} };
-					turn.steps.push(step);
-					turn.toolCallById.set(step.toolCallId, step);
-				}
-			}
-		} else {
-			const turn = ensureTurn();
-			let step = turn.toolCallById.get(message.toolCallId);
-			if (!step) {
-				step = { kind: "toolCall", toolCallId: message.toolCallId, toolName: message.toolName, arguments: {} };
-				turn.steps.push(step);
-				turn.toolCallById.set(step.toolCallId, step);
-			}
-			step.result = { content: message.content, isError: message.isError, fallbackText: rawToolResultText(message) };
-		}
-	}
-	flushTurn();
-	return turns;
-}
-
-function appendAssistantTextStep(steps: ParsedTurnStep[], text: string): void {
-	if (!text) return;
-	const last = steps.at(-1);
-	if (last?.kind === "assistantText") {
-		steps[steps.length - 1] = { kind: "assistantText", text: `${last.text}${text}` };
-		return;
-	}
-	steps.push({ kind: "assistantText", text });
-}
-
-export function extractCurrentActionText(request: CursorRunRequest): string {
-	const last = request.context.messages.at(-1);
-	return last ? textFromMessage(last) : "";
-}
-
-export function extractCurrentActionImages(request: CursorRunRequest): readonly ImageContent[] {
-	const last = request.context.messages.at(-1);
-	if (!last || last.role !== "user") return [];
-	return imagesFromUserMessage(last);
-}
-
-function imagesFromUserMessage(message: Extract<CursorRunRequest["context"]["messages"][number], { readonly role: "user" }>): readonly ImageContent[] {
-	if (typeof message.content === "string") return [];
-	return message.content.filter((part): part is ImageContent => part.type === "image");
-}
-
-function rawToolResultText(message: Extract<CursorRunRequest["context"]["messages"][number], { readonly role: "toolResult" }>): string {
-	return message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
-}
-
-function textFromMessage(message: CursorRunRequest["context"]["messages"][number]): string {
-	if (message.role === "user") {
-		if (typeof message.content === "string") return message.content;
-		return message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
-	}
-	if (message.role === "assistant") {
-		return message.content.map((part) => {
-			if (part.type === "text") return part.text;
-			if (part.type === "thinking") return part.thinking;
-			return `toolCall:${part.id}:${part.name}:${JSON.stringify(part.arguments)}`;
-		}).join("\n");
-	}
-	return rawToolResultText(message);
-}
-
-function buildSelectedContextBlob(rootPromptBlobIds: readonly Uint8Array[], clientName: string): Uint8Array {
-	const parts: Uint8Array[] = [];
-	for (const blobId of rootPromptBlobIds) {
-		parts.push(new Uint8Array([0x0a, blobId.length, ...blobId]));
-	}
-	const clientBytes = textEncoder.encode(clientName);
-	parts.push(new Uint8Array([0xb2, 0x01, clientBytes.length, ...clientBytes]));
-	return concatBytes(...parts);
-}
-
-function storeAsBlob(data: Uint8Array, blobStore: Map<string, Uint8Array>): Uint8Array {
-	const blobId = new Uint8Array(createHash("sha256").update(data).digest());
-	blobStore.set(blobKey(blobId), data);
-	return blobId;
-}
-
-export function blobKey(blobId: Uint8Array): string {
-	return Buffer.from(blobId).toString("hex");
-}
-
-function concatBytes(...parts: readonly Uint8Array[]): Uint8Array {
-	const output = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
-	let offset = 0;
-	for (const part of parts) {
-		output.set(part, offset);
-		offset += part.length;
-	}
-	return output;
-}

package/dist/builtin/cursor/src/proto/protobuf-codec-wire.ts

@@ -1,248 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { create, toBinary } from "@bufbuild/protobuf";
-import type { CursorControlMessage, CursorProtocolMessage, CursorServerMessage, CursorToolResultContent } from "../transport.js";
-import {
-	AgentClientMessageSchema,
-	BackgroundShellSpawnResultSchema,
-	ConversationStateStructureSchema,
-	DeleteRejectedSchema,
-	DeleteResultSchema,
-	DiagnosticsResultSchema,
-	ExecClientMessageSchema,
-	FetchErrorSchema,
-	FetchResultSchema,
-	GrepErrorSchema,
-	GrepResultSchema,
-	KvClientMessageSchema,
-	LsRejectedSchema,
-	LsResultSchema,
-	McpErrorSchema,
-	McpImageContentSchema,
-	McpResultSchema,
-	McpSuccessSchema,
-	McpTextContentSchema,
-	McpToolErrorSchema,
-	McpToolResultContentItemSchema,
-	McpToolResultSchema,
-	ReadRejectedSchema,
-	ReadResultSchema,
-	RequestContextResultSchema,
-	RequestContextSchema,
-	RequestContextSuccessSchema,
-	ShellRejectedSchema,
-	ShellResultSchema,
-	ShellStreamSchema,
-	WriteRejectedSchema,
-	WriteResultSchema,
-	WriteShellStdinErrorSchema,
-	WriteShellStdinResultSchema,
-	type AgentServerMessage,
-	type ExecServerMessage,
-	type KvServerMessage,
-	type McpToolDefinition,
-} from "./agent_pb.js";
-import { decodeStrictBase64ImageData } from "./protobuf-codec-base64.js";
-import { decodeMcpArgsMap } from "./protobuf-codec-json.js";
-
-const NATIVE_EXEC_REJECT_REASON = "Tool not available in this environment. Use the MCP tools provided instead.";
-
-const EXEC_CASE_FIELD_NUMBERS: ReadonlyMap<string, number> = new Map([
-	["shellArgs", 2],
-	["writeArgs", 3],
-	["deleteArgs", 4],
-	["grepArgs", 5],
-	["readArgs", 7],
-	["lsArgs", 8],
-	["diagnosticsArgs", 9],
-	["requestContextArgs", 10],
-	["mcpArgs", 11],
-	["shellStreamArgs", 14],
-	["backgroundShellSpawnArgs", 16],
-	["listMcpResourcesExecArgs", 17],
-	["readMcpResourceExecArgs", 18],
-	["fetchArgs", 20],
-	["recordScreenArgs", 21],
-	["computerUseArgs", 22],
-	["writeShellStdinArgs", 23],
-]);
-
-export function decodeAgentServerMessage(message: AgentServerMessage): readonly CursorProtocolMessage[] {
-	switch (message.message.case) {
-		case "interactionUpdate": {
-			const update = message.message.value;
-			if (update.message.case === "textDelta") return update.message.value.text ? [{ type: "textDelta", text: update.message.value.text }] : [];
-			if (update.message.case === "thinkingDelta") return update.message.value.text ? [{ type: "thinkingDelta", text: update.message.value.text }] : [];
-			if (update.message.case === "tokenDelta") return [{ type: "usage", kind: "outputDelta", outputTokens: update.message.value.tokens }];
-			return [];
-		}
-		case "conversationCheckpointUpdate": {
-			const checkpointState = message.message.value;
-			const checkpoint = toBinary(ConversationStateStructureSchema, checkpointState);
-			const messages: CursorProtocolMessage[] = [{ type: "conversationCheckpoint", checkpoint }];
-			if (checkpointState.tokenDetails) messages.push({ type: "usage", kind: "checkpoint", usedTokens: checkpointState.tokenDetails.usedTokens });
-			return messages;
-		}
-		case "kvServerMessage":
-			return decodeKvServerMessage(message.message.value);
-		case "execServerMessage":
-			return decodeExecServerMessage(message.message.value);
-		case "interactionQuery":
-			return [];
-		default:
-			return [];
-	}
-}
-
-function decodeKvServerMessage(kvMessage: KvServerMessage): readonly CursorControlMessage[] {
-	if (kvMessage.message.case === "getBlobArgs") return [{ type: "kvGetBlob", id: kvMessage.id, blobId: kvMessage.message.value.blobId }];
-	if (kvMessage.message.case === "setBlobArgs") {
-		return [{ type: "kvSetBlob", id: kvMessage.id, blobId: kvMessage.message.value.blobId, blobData: kvMessage.message.value.blobData }];
-	}
-	return [];
-}
-
-function decodeExecServerMessage(execMessage: ExecServerMessage): readonly CursorProtocolMessage[] {
-	const execCase = execMessage.message.case;
-	if (execCase === "requestContextArgs") {
-		return [{ type: "requestContext", ...(execMessage.execId ? { execId: execMessage.execId } : {}), execNumericId: execMessage.id }];
-	}
-	if (execCase === "mcpArgs") {
-		const mcpArgs = execMessage.message.value;
-		return [{
-			type: "toolCall",
-			id: mcpArgs.toolCallId || randomUUID(),
-			name: mcpArgs.toolName || mcpArgs.name || "cursor_tool",
-			argumentsJson: JSON.stringify(decodeMcpArgsMap(mcpArgs.args ?? {})),
-			...(execMessage.execId ? { execId: execMessage.execId } : {}),
-			execNumericId: execMessage.id,
-		}];
-	}
-	const fieldNumber = execCase ? EXEC_CASE_FIELD_NUMBERS.get(execCase) : undefined;
-	return fieldNumber === undefined ? [] : [{ type: "nonMcpExec", fieldNumber, ...(execMessage.execId ? { execId: execMessage.execId } : {}), execNumericId: execMessage.id }];
-}
-
-export function encodeKvClientMessage(id: number, messageCase: "getBlobResult" | "setBlobResult", value: unknown): Uint8Array {
-	const response = create(KvClientMessageSchema, { id, message: { case: messageCase, value } as never });
-	const clientMessage = create(AgentClientMessageSchema, { message: { case: "kvClientMessage", value: response } });
-	return toBinary(AgentClientMessageSchema, clientMessage);
-}
-
-export function encodeRequestContextResult(message: Extract<CursorControlMessage, { readonly type: "requestContext" }>, toolDefinitions: readonly McpToolDefinition[]): Uint8Array {
-	const requestContext = create(RequestContextSchema, {
-		rules: [],
-		repositoryInfo: [],
-		tools: [...toolDefinitions],
-		gitRepos: [],
-		projectLayouts: [],
-		mcpInstructions: [],
-		fileContents: {},
-		customSubagents: [],
-	});
-	const result = create(RequestContextResultSchema, {
-		result: { case: "success", value: create(RequestContextSuccessSchema, { requestContext }) },
-	});
-	return encodeExecClientMessage(message.execNumericId, message.execId, "requestContextResult", result);
-}
-
-export function encodeNativeExecRejection(message: Extract<CursorServerMessage, { readonly type: "nonMcpExec" }>): Uint8Array | undefined {
-	const result = createNativeExecResult(message.fieldNumber);
-	return result ? encodeExecClientMessage(message.execNumericId, message.execId, result.caseName, result.value) : undefined;
-}
-
-function createNativeExecResult(fieldNumber: number): { readonly caseName: string; readonly value: unknown } | undefined {
-	switch (fieldNumber) {
-		case 2:
-			return { caseName: "shellResult", value: create(ShellResultSchema, { result: { case: "rejected", value: createShellRejected() } }) };
-		case 3:
-			return { caseName: "writeResult", value: create(WriteResultSchema, { result: { case: "rejected", value: create(WriteRejectedSchema, { path: "", reason: NATIVE_EXEC_REJECT_REASON }) } }) };
-		case 4:
-			return { caseName: "deleteResult", value: create(DeleteResultSchema, { result: { case: "rejected", value: create(DeleteRejectedSchema, { path: "", reason: NATIVE_EXEC_REJECT_REASON }) } }) };
-		case 5:
-			return { caseName: "grepResult", value: create(GrepResultSchema, { result: { case: "error", value: create(GrepErrorSchema, { error: NATIVE_EXEC_REJECT_REASON }) } }) };
-		case 7:
-			return { caseName: "readResult", value: create(ReadResultSchema, { result: { case: "rejected", value: create(ReadRejectedSchema, { path: "", reason: NATIVE_EXEC_REJECT_REASON }) } }) };
-		case 8:
-			return { caseName: "lsResult", value: create(LsResultSchema, { result: { case: "rejected", value: create(LsRejectedSchema, { path: "", reason: NATIVE_EXEC_REJECT_REASON }) } }) };
-		case 9:
-			return { caseName: "diagnosticsResult", value: create(DiagnosticsResultSchema, {}) };
-		case 14:
-			return { caseName: "shellStream", value: create(ShellStreamSchema, { event: { case: "rejected", value: createShellRejected() } }) };
-		case 16:
-			return { caseName: "backgroundShellSpawnResult", value: create(BackgroundShellSpawnResultSchema, { result: { case: "rejected", value: createShellRejected() } }) };
-		case 17:
-			return { caseName: "listMcpResourcesExecResult", value: create(McpResultSchema, {}) };
-		case 18:
-			return { caseName: "readMcpResourceExecResult", value: create(McpResultSchema, {}) };
-		case 20:
-			return { caseName: "fetchResult", value: create(FetchResultSchema, { result: { case: "error", value: create(FetchErrorSchema, { url: "", error: NATIVE_EXEC_REJECT_REASON }) } }) };
-		case 21:
-			return { caseName: "recordScreenResult", value: create(McpResultSchema, {}) };
-		case 22:
-			return { caseName: "computerUseResult", value: create(McpResultSchema, {}) };
-		case 23:
-			return { caseName: "writeShellStdinResult", value: create(WriteShellStdinResultSchema, { result: { case: "error", value: create(WriteShellStdinErrorSchema, { error: NATIVE_EXEC_REJECT_REASON }) } }) };
-		default:
-			return undefined;
-	}
-}
-
-function createShellRejected(): ReturnType<typeof create<typeof ShellRejectedSchema>> {
-	return create(ShellRejectedSchema, {
-		command: "",
-		workingDirectory: "",
-		reason: NATIVE_EXEC_REJECT_REASON,
-		isReadonly: false,
-	});
-}
-
-export function encodeExecClientMessage(execNumericId: number | undefined, execId: string | undefined, messageCase: string, value: unknown): Uint8Array {
-	const execClientMessage = create(ExecClientMessageSchema, {
-		id: execNumericId ?? 0,
-		execId: execId ?? "",
-		message: { case: messageCase, value } as never,
-	});
-	const clientMessage = create(AgentClientMessageSchema, { message: { case: "execClientMessage", value: execClientMessage } });
-	return toBinary(AgentClientMessageSchema, clientMessage);
-}
-
-export function createMcpToolResult(content: string | readonly CursorToolResultContent[], isError: boolean, fallbackText = ""): ReturnType<typeof create<typeof McpResultSchema>> {
-	const text = typeof content === "string" ? content : fallbackText;
-	if (isError) {
-		return create(McpResultSchema, { result: { case: "error", value: create(McpErrorSchema, { error: text }) } });
-	}
-	return create(McpResultSchema, {
-		result: {
-			case: "success",
-			value: createMcpSuccess(content, fallbackText),
-		},
-	});
-}
-
-export function createMcpToolCallResult(content: string | readonly CursorToolResultContent[], isError: boolean, fallbackText = ""): ReturnType<typeof create<typeof McpToolResultSchema>> {
-	const text = typeof content === "string" ? content : fallbackText;
-	if (isError) {
-		return create(McpToolResultSchema, { result: { case: "error", value: create(McpToolErrorSchema, { error: text }) } });
-	}
-	return create(McpToolResultSchema, { result: { case: "success", value: createMcpSuccess(content, fallbackText) } });
-}
-
-function createMcpSuccess(content: string | readonly CursorToolResultContent[], fallbackText: string): ReturnType<typeof create<typeof McpSuccessSchema>> {
-	const items = typeof content === "string"
-		? [createTextContentItem(content)]
-		: content.map((part, index) => part.type === "text" ? createTextContentItem(part.text) : createImageContentItem(part.data, part.mimeType, index));
-	return create(McpSuccessSchema, {
-		content: items.length > 0 ? items : [createTextContentItem(fallbackText)],
-		isError: false,
-	});
-}
-
-function createTextContentItem(text: string): ReturnType<typeof create<typeof McpToolResultContentItemSchema>> {
-	return create(McpToolResultContentItemSchema, { content: { case: "text", value: create(McpTextContentSchema, { text }) } });
-}
-
-function createImageContentItem(data: string, mimeType: string, index: number): ReturnType<typeof create<typeof McpToolResultContentItemSchema>> {
-	return create(McpToolResultContentItemSchema, {
-		content: { case: "image", value: create(McpImageContentSchema, { data: decodeStrictBase64ImageData(data, { kind: "MCP image", mimeType, index }), mimeType }) },
-	});
-}
-