@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.2

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

@@ -1,72 +1,22 @@
-import { createHash, randomUUID } from "node:crypto";
-import { create, fromBinary, fromJson, type JsonValue as ProtobufJsonValue, toBinary, toJson } from "@bufbuild/protobuf";
-import { ValueSchema } from "@bufbuild/protobuf/wkt";
-import { createCursorExperimentalProtocolError, parseJsonObject, parseJsonValue, type JsonObject, type JsonValue } from "../config.js";
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { createCursorExperimentalProtocolError } from "../config.js";
 import type { CursorUsableModel } from "../model-mapper.js";
-import type { CursorConnectFrame, CursorControlMessage, CursorProtocolCodec, CursorProtocolMessage, CursorRunRequest, CursorServerMessage, CursorToolResultMessage } from "../transport.js";
+import type { CursorConnectFrame, CursorProtocolCodec, CursorProtocolMessage, CursorRunRequest, CursorToolResultMessage } from "../transport.js";
 import {
 	AgentClientMessageSchema,
-	AgentConversationTurnStructureSchema,
-	AgentRunRequestSchema,
 	AgentServerMessageSchema,
-	AssistantMessageSchema,
-	BackgroundShellSpawnResultSchema,
 	CancelActionSchema,
 	ClientHeartbeatSchema,
 	ConversationActionSchema,
-	ConversationStateStructureSchema,
-	ConversationStepSchema,
-	ConversationTurnStructureSchema,
-	DeleteRejectedSchema,
-	DeleteResultSchema,
-	DiagnosticsResultSchema,
-	ExecClientMessageSchema,
-	FetchErrorSchema,
-	FetchResultSchema,
 	GetBlobResultSchema,
 	GetUsableModelsRequestSchema,
 	GetUsableModelsResponseSchema,
-	GrepErrorSchema,
-	GrepResultSchema,
-	KvClientMessageSchema,
-	LsRejectedSchema,
-	LsResultSchema,
-	McpArgsSchema,
-	McpErrorSchema,
-	McpResultSchema,
-	McpSuccessSchema,
-	McpTextContentSchema,
-	McpToolCallSchema,
-	McpToolDefinitionSchema,
-	McpToolErrorSchema,
-	McpToolResultContentItemSchema,
-	McpToolResultSchema,
-	ModelDetailsSchema,
-	ReadRejectedSchema,
-	ReadResultSchema,
-	RequestContextResultSchema,
-	RequestContextSchema,
-	RequestContextSuccessSchema,
-	SelectedContextSchema,
 	SetBlobResultSchema,
-	ShellRejectedSchema,
-	ShellResultSchema,
-	ShellStreamSchema,
-	ToolCallSchema,
-	UserMessageActionSchema,
-	UserMessageSchema,
-	WriteRejectedSchema,
-	WriteResultSchema,
-	WriteShellStdinErrorSchema,
-	WriteShellStdinResultSchema,
-	type AgentServerMessage,
-	type ConversationStateStructure,
-	type ExecServerMessage,
-	type KvServerMessage,
 	type McpToolDefinition,
 	type ModelDetails,
-	type UserMessage,
 } from "./agent_pb.js";
+import { blobKey, buildCursorRequest, buildMcpToolDefinitions, extractCurrentActionText, parseHistoricalTurns } from "./protobuf-codec-request.js";
+import { createMcpToolResult, decodeAgentServerMessage, encodeExecClientMessage, encodeKvClientMessage, encodeNativeExecRejection, encodeRequestContextResult } from "./protobuf-codec-wire.js";
 
 // Cursor protocol codec intentionally follows the MIT-licensed
 // ndraiman/pi-cursor-provider implementation. The request/control bytes are
@@ -80,51 +30,6 @@ interface StoredCursorConversationState {
 }
 
 
-interface ParsedAssistantTextStep {
-	readonly kind: "assistantText";
-	readonly text: string;
-}
-
-interface ParsedToolCallStep {
-	readonly kind: "toolCall";
-	readonly toolCallId: string;
-	readonly toolName: string;
-	readonly arguments: JsonObject;
-	result?: { readonly content: string; readonly isError: boolean };
-}
-
-type ParsedTurnStep = ParsedAssistantTextStep | ParsedToolCallStep;
-
-interface ParsedTurn {
-	readonly userText: string;
-	readonly steps: ParsedTurnStep[];
-}
-
-const CURSOR_PROTO_CLIENT_NAME = "pi";
-const NATIVE_EXEC_REJECT_REASON = "Tool not available in this environment. Use the MCP tools provided instead.";
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-
-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 class CursorProtobufProtocolCodec implements CursorProtocolCodec {
 	readonly #blobStores = new Map<string, Map<string, Uint8Array>>();
 	readonly #toolDefinitions = new Map<string, readonly McpToolDefinition[]>();
@@ -292,426 +197,3 @@ function unwrapConnectUnaryBody(data: Uint8Array): Uint8Array | undefined {
 	return undefined;
 }
 
-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),
-		});
-	});
-}
-
-function buildCursorRequest(
-	modelId: string,
-	systemPrompt: string,
-	userText: string,
-	turns: readonly ParsedTurn[],
-	conversationId: string,
-	checkpoint: Uint8Array | null,
-	existingBlobStore?: Map<string, Uint8Array>,
-): { 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);
-	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);
-		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): UserMessage {
-	const messageId = randomUUID();
-	return create(UserMessageSchema, {
-		text,
-		messageId,
-		selectedContext: create(SelectedContextSchema, {}),
-		mode: 1,
-		selectedContextBlob,
-		correlationId: messageId,
-	});
-}
-
-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) } : {}),
-	});
-	return toBinary(ConversationStepSchema, create(ConversationStepSchema, {
-		message: {
-			case: "toolCall",
-			value: create(ToolCallSchema, { tool: { case: "mcpToolCall", value: mcpToolCall } }),
-		},
-	}));
-}
-
-function parseHistoricalTurns(messages: readonly CursorRunRequest["context"]["messages"][number][]): readonly ParsedTurn[] {
-	const turns: ParsedTurn[] = [];
-	let currentTurn: { userText: string; steps: ParsedTurnStep[]; toolCallById: Map<string, ParsedToolCallStep> } | undefined;
-	const ensureTurn = (): { userText: string; steps: ParsedTurnStep[]; toolCallById: Map<string, ParsedToolCallStep> } => {
-		currentTurn ??= { userText: "", steps: [], toolCallById: new Map() };
-		return currentTurn;
-	};
-	const flushTurn = (): void => {
-		if (!currentTurn) return;
-		if (currentTurn.userText || currentTurn.steps.length > 0) turns.push({ userText: currentTurn.userText, steps: currentTurn.steps });
-		currentTurn = undefined;
-	};
-	for (const message of messages) {
-		if (message.role === "user") {
-			flushTurn();
-			currentTurn = { userText: textFromMessage(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: rawToolResultText(message), isError: message.isError };
-		}
-	}
-	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 });
-}
-
-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 }];
-}
-
-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);
-}
-
-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);
-}
-
-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,
-	});
-}
-
-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);
-}
-
-function createMcpToolResult(text: string, isError: boolean): ReturnType<typeof create<typeof McpResultSchema>> {
-	if (isError) {
-		return create(McpResultSchema, { result: { case: "error", value: create(McpErrorSchema, { error: text }) } });
-	}
-	return create(McpResultSchema, {
-		result: {
-			case: "success",
-			value: createMcpSuccess(text),
-		},
-	});
-}
-
-function createMcpToolCallResult(text: string, isError: boolean): ReturnType<typeof create<typeof McpToolResultSchema>> {
-	if (isError) {
-		return create(McpToolResultSchema, { result: { case: "error", value: create(McpToolErrorSchema, { error: text }) } });
-	}
-	return create(McpToolResultSchema, { result: { case: "success", value: createMcpSuccess(text) } });
-}
-
-function createMcpSuccess(text: string): ReturnType<typeof create<typeof McpSuccessSchema>> {
-	return create(McpSuccessSchema, {
-		content: [create(McpToolResultContentItemSchema, { content: { case: "text", value: create(McpTextContentSchema, { text }) } })],
-		isError: false,
-	});
-}
-
-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));
-	}
-}
-
-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);
-	}
-}
-
-function decodeMcpArgsMap(args: Record<string, Uint8Array>): JsonObject {
-	const decoded: JsonObject = {};
-	for (const [key, value] of Object.entries(args)) decoded[key] = decodeMcpArgValue(value);
-	return decoded;
-}
-
-function serializableJsonValue(value: object): JsonValue {
-	return parseJsonValue(JSON.stringify(value)) ?? {};
-}
-
-function extractCurrentActionText(request: CursorRunRequest): string {
-	const last = request.context.messages.at(-1);
-	return last ? textFromMessage(last) : "";
-}
-
-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;
-}
-
-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;
-}