@clinebot/llms 0.0.0

package/src/providers/transform/ai-sdk-community-format.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import type { Message } from "../types/messages";
+import { toAiSdkMessages } from "./ai-sdk-community-format";
+
+describe("ai sdk community format conversion", () => {
+	it("converts file content to text and serializes tool_result file blocks", () => {
+		const messages: Message[] = [
+			{
+				role: "user",
+				content: [
+					{ type: "file", path: "/repo/readme.md", content: "hello file body" },
+				],
+			},
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "run_commands",
+						input: ["ls -la", "pwd"] as unknown as Record<string, unknown>,
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_1",
+						content: [
+							{
+								type: "file",
+								path: "/repo/readme.md",
+								content: "hello file body",
+							},
+						],
+					},
+				],
+			},
+		];
+
+		const converted = toAiSdkMessages("system", messages);
+		expect(converted[0]).toMatchObject({ role: "system", content: "system" });
+		expect(converted[1]).toMatchObject({
+			role: "user",
+			content: [
+				{
+					type: "text",
+					text: '<file_content path="/repo/readme.md">\nhello file body\n</file_content>',
+				},
+			],
+		});
+		const assistantParts = Array.isArray(converted[2]?.content)
+			? converted[2].content
+			: [];
+		expect(assistantParts[0]).toMatchObject({
+			args: { commands: ["ls -la", "pwd"] },
+		});
+		expect(converted[3]).toMatchObject({
+			role: "tool",
+			content: [
+				{
+					type: "tool-result",
+					toolCallId: "call_1",
+					output:
+						'<file_content path="/repo/readme.md">\nhello file body\n</file_content>',
+					isError: false,
+				},
+			],
+		});
+	});
+});

package/src/providers/transform/ai-sdk-community-format.ts

@@ -0,0 +1,115 @@
+import { formatFileContentBlock } from "@clinebot/shared";
+import type { Message } from "../types/messages";
+import {
+	normalizeToolUseInput,
+	serializeToolResultContent,
+} from "./content-format";
+
+export type AiSdkMessagePart = Record<string, unknown>;
+export type AiSdkMessage = {
+	role: "system" | "user" | "assistant" | "tool";
+	content: string | AiSdkMessagePart[];
+};
+
+export function toAiSdkMessages(
+	systemContent: string | AiSdkMessagePart[],
+	messages: Message[],
+	options?: { assistantToolCallArgKey?: "args" | "input" },
+): AiSdkMessage[] {
+	const toolCallArgKey = options?.assistantToolCallArgKey ?? "args";
+	const result: AiSdkMessage[] = [{ role: "system", content: systemContent }];
+	const toolNamesById = new Map<string, string>();
+
+	for (const message of messages) {
+		if (typeof message.content === "string") {
+			result.push({ role: message.role, content: message.content });
+			continue;
+		}
+
+		if (message.role === "assistant") {
+			const parts: AiSdkMessagePart[] = [];
+			for (const block of message.content) {
+				if (block.type === "text") {
+					parts.push({ type: "text", text: block.text });
+					continue;
+				}
+
+				if (block.type === "file") {
+					parts.push({
+						type: "text",
+						text: formatFileContentBlock(block.path, block.content),
+					});
+					continue;
+				}
+
+				if (block.type === "tool_use") {
+					toolNamesById.set(block.id, block.name);
+					parts.push({
+						type: "tool-call",
+						toolCallId: block.id,
+						toolName: block.name,
+						[toolCallArgKey]: normalizeToolUseInput(block.input),
+					});
+				}
+			}
+
+			if (parts.length > 0) {
+				result.push({ role: "assistant", content: parts });
+			}
+			continue;
+		}
+
+		const userParts: AiSdkMessagePart[] = [];
+		for (const block of message.content) {
+			if (block.type === "text") {
+				userParts.push({ type: "text", text: block.text });
+				continue;
+			}
+
+			if (block.type === "file") {
+				userParts.push({
+					type: "text",
+					text: formatFileContentBlock(block.path, block.content),
+				});
+				continue;
+			}
+
+			if (block.type === "image") {
+				userParts.push({
+					type: "image",
+					image: Buffer.from(block.data, "base64"),
+					mediaType: block.mediaType,
+				});
+				continue;
+			}
+
+			if (block.type === "tool_result") {
+				if (userParts.length > 0) {
+					result.push({
+						role: "user",
+						content: userParts.splice(0, userParts.length),
+					});
+				}
+
+				result.push({
+					role: "tool",
+					content: [
+						{
+							type: "tool-result",
+							toolCallId: block.tool_use_id,
+							toolName: toolNamesById.get(block.tool_use_id) ?? "tool",
+							output: serializeToolResultContent(block.content),
+							isError: block.is_error ?? false,
+						},
+					],
+				});
+			}
+		}
+
+		if (userParts.length > 0) {
+			result.push({ role: "user", content: userParts });
+		}
+	}
+
+	return result;
+}

package/src/providers/transform/anthropic-format.ts

@@ -0,0 +1,218 @@
+/**
+ * Anthropic Message Format Converter
+ *
+ * Converts our unified Message format to Anthropic's MessageParam format.
+ */
+
+import type { Anthropic } from "@anthropic-ai/sdk";
+import { formatFileContentBlock } from "@clinebot/shared";
+import type {
+	ContentBlock,
+	FileContent,
+	ImageContent,
+	Message,
+	RedactedThinkingContent,
+	TextContent,
+	ThinkingContent,
+	ToolResultContent,
+	ToolUseContent,
+} from "../types/messages";
+import { normalizeToolUseInput } from "./content-format";
+
+type AnthropicMessage = Anthropic.MessageParam;
+type AnthropicContentBlock = Anthropic.ContentBlockParam;
+
+/**
+ * Convert messages to Anthropic format
+ *
+ * @param messages - Messages to convert
+ * @param enableCaching - Whether to add cache control markers
+ */
+export function convertToAnthropicMessages(
+	messages: Message[],
+	enableCaching = false,
+): AnthropicMessage[] {
+	const result: AnthropicMessage[] = [];
+
+	for (const message of messages) {
+		const converted = convertMessage(
+			message,
+			enableCaching && messages.indexOf(message) === messages.length - 1,
+		);
+		if (converted) {
+			result.push(converted);
+		}
+	}
+
+	return result;
+}
+
+function convertMessage(
+	message: Message,
+	addCacheControl: boolean,
+): AnthropicMessage | null {
+	const { role, content } = message;
+
+	// Simple string content
+	if (typeof content === "string") {
+		const textBlock: AnthropicContentBlock = { type: "text", text: content };
+		if (addCacheControl) {
+			(textBlock as any).cache_control = { type: "ephemeral" };
+		}
+		return { role, content: [textBlock] };
+	}
+
+	// Array content - need to process blocks
+	const blocks = convertContentBlocks(content, addCacheControl);
+	if (blocks.length === 0) {
+		return null;
+	}
+
+	return { role, content: blocks };
+}
+
+function convertContentBlocks(
+	content: ContentBlock[],
+	addCacheControl: boolean,
+): AnthropicContentBlock[] {
+	const blocks: AnthropicContentBlock[] = [];
+
+	for (let i = 0; i < content.length; i++) {
+		const block = content[i];
+		const isLast = i === content.length - 1;
+		const converted = convertContentBlock(block, addCacheControl && isLast);
+		if (converted) {
+			blocks.push(converted);
+		}
+	}
+
+	return blocks;
+}
+
+function convertContentBlock(
+	block: ContentBlock,
+	addCacheControl: boolean,
+): AnthropicContentBlock | null {
+	switch (block.type) {
+		case "text": {
+			const textBlock = block as TextContent;
+			const result: AnthropicContentBlock = {
+				type: "text",
+				text: textBlock.text,
+			};
+			if (addCacheControl) {
+				(result as any).cache_control = { type: "ephemeral" };
+			}
+			return result;
+		}
+
+		case "file": {
+			const fileBlock = block as FileContent;
+			return {
+				type: "text",
+				text: formatFileContentBlock(fileBlock.path, fileBlock.content),
+			};
+		}
+
+		case "image": {
+			const imageBlock = block as ImageContent;
+			return {
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: imageBlock.mediaType as
+						| "image/jpeg"
+						| "image/png"
+						| "image/gif"
+						| "image/webp",
+					data: imageBlock.data,
+				},
+			};
+		}
+
+		case "tool_use": {
+			const toolBlock = block as ToolUseContent;
+			return {
+				type: "tool_use",
+				id: toolBlock.id,
+				name: toolBlock.name,
+				input: normalizeToolUseInput(toolBlock.input),
+			};
+		}
+
+		case "tool_result": {
+			const resultBlock = block as ToolResultContent;
+			let resultContent: Anthropic.ToolResultBlockParam["content"];
+
+			if (typeof resultBlock.content === "string") {
+				resultContent = resultBlock.content;
+			} else {
+				// Convert array of text/image to Anthropic format
+				resultContent = resultBlock.content.map((item) => {
+					if (item.type === "text") {
+						return { type: "text" as const, text: item.text };
+					} else if (item.type === "file") {
+						const fileItem = item as FileContent;
+						return {
+							type: "text" as const,
+							text: formatFileContentBlock(fileItem.path, fileItem.content),
+						};
+					} else {
+						return {
+							type: "image" as const,
+							source: {
+								type: "base64" as const,
+								media_type: item.mediaType as
+									| "image/jpeg"
+									| "image/png"
+									| "image/gif"
+									| "image/webp",
+								data: item.data,
+							},
+						};
+					}
+				});
+			}
+
+			return {
+				type: "tool_result",
+				tool_use_id: resultBlock.tool_use_id,
+				content: resultContent,
+				is_error: resultBlock.is_error,
+			};
+		}
+
+		case "thinking": {
+			const thinkingBlock = block as ThinkingContent;
+			return {
+				type: "thinking",
+				thinking: thinkingBlock.thinking,
+				signature: thinkingBlock.signature,
+			} as any; // Anthropic SDK types may not include this yet
+		}
+
+		case "redacted_thinking": {
+			const redactedBlock = block as RedactedThinkingContent;
+			return {
+				type: "redacted_thinking",
+				data: redactedBlock.data,
+			} as any;
+		}
+
+		default:
+			return null;
+	}
+}
+
+/**
+ * Convert tool definitions to Anthropic format
+ */
+export function convertToolsToAnthropic(
+	tools: Array<{ name: string; description: string; inputSchema: unknown }>,
+): Anthropic.Tool[] {
+	return tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		input_schema: tool.inputSchema as Anthropic.Tool.InputSchema,
+	}));
+}

package/src/providers/transform/content-format.ts

@@ -0,0 +1,34 @@
+import { formatFileContentBlock } from "@clinebot/shared";
+import type { FileContent, ImageContent, TextContent } from "../types/messages";
+
+export function normalizeToolUseInput(
+	input: Record<string, unknown>,
+): Record<string, unknown> {
+	if (Array.isArray(input)) {
+		return { commands: input };
+	}
+	return input;
+}
+
+export function serializeToolResultContent(
+	content: string | Array<TextContent | ImageContent | FileContent>,
+): string {
+	if (typeof content === "string") {
+		return content;
+	}
+
+	const parts: string[] = [];
+	for (const part of content) {
+		if (part.type === "text") {
+			parts.push(part.text);
+			continue;
+		}
+		if (part.type === "file") {
+			parts.push(formatFileContentBlock(part.path, part.content));
+			continue;
+		}
+		parts.push(JSON.stringify(part));
+	}
+
+	return parts.join("\n");
+}