@clinebot/llms 0.0.0

package/src/providers/transform/format-conversion.test.ts

@@ -0,0 +1,310 @@
+import { describe, expect, it } from "vitest";
+import type { Message } from "../types/messages";
+import {
+	convertToAnthropicMessages,
+	convertToGeminiMessages,
+	convertToOpenAIMessages,
+	convertToolsToAnthropic,
+	convertToolsToGemini,
+	convertToolsToOpenAI,
+	convertToR1Messages,
+} from "./index";
+
+describe("format conversion", () => {
+	it("converts file content blocks to text for user and tool_result payloads", () => {
+		const fileText =
+			'<file_content path="/repo/README.md">\nhello from file\n</file_content>';
+		const messages: Message[] = [
+			{
+				role: "user",
+				content: [
+					{ type: "file", path: "/repo/README.md", content: "hello from file" },
+				],
+			},
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "read_file",
+						input: { path: "/repo/README.md" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_1",
+						content: [
+							{
+								type: "file",
+								path: "/repo/README.md",
+								content: "hello from file",
+							},
+						],
+					},
+				],
+			},
+		];
+
+		const openai = convertToOpenAIMessages(messages) as any[];
+		expect(openai[0]).toMatchObject({ role: "user", content: fileText });
+		expect(openai[2]).toMatchObject({ role: "tool", content: fileText });
+
+		const gemini = convertToGeminiMessages(messages) as any[];
+		expect(gemini[0]?.parts?.[0]?.text).toBe(fileText);
+		expect(gemini[2]?.parts?.[0]?.functionResponse?.response?.result).toBe(
+			fileText,
+		);
+
+		const anthropic = convertToAnthropicMessages(messages) as any[];
+		expect(anthropic[0]?.content?.[0]).toMatchObject({
+			type: "text",
+			text: fileText,
+		});
+		expect(anthropic[2]?.content?.[0]).toMatchObject({
+			type: "tool_result",
+			content: [{ type: "text", text: fileText }],
+		});
+
+		const r1 = convertToR1Messages(messages) as any[];
+		expect(r1[0]).toMatchObject({ role: "user", content: fileText });
+		expect(r1[2]).toMatchObject({ role: "tool", content: fileText });
+	});
+
+	it("replays gemini thought signatures on text/tool_use/thinking parts", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "start" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "run_commands",
+						input: { command: "echo hi" },
+						signature: "sig-a",
+					},
+					{ type: "thinking", thinking: "need to run", signature: "sig-think" },
+					{ type: "text", text: "done", signature: "sig-text" },
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{ type: "tool_result", tool_use_id: "run_commands", content: "ok" },
+				],
+			},
+		];
+
+		const gemini = convertToGeminiMessages(messages);
+		const assistant = gemini[1] as any;
+		expect(assistant.role).toBe("model");
+		expect(assistant.parts[0].functionCall.name).toBe("run_commands");
+		expect(assistant.parts[0].thoughtSignature).toBe("sig-a");
+		expect(assistant.parts[1].thought).toBe(true);
+		expect(assistant.parts[1].thoughtSignature).toBe("sig-think");
+		expect(assistant.parts[2].text).toBe("done");
+		expect(assistant.parts[2].thoughtSignature).toBe("sig-text");
+	});
+
+	it("converts multiple tool_result blocks for openai without dropping any", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "check both" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "get_weather",
+						input: { city: "Paris" },
+						signature: "sig1",
+					},
+					{
+						type: "tool_use",
+						id: "call_2",
+						name: "get_weather",
+						input: { city: "London" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_1",
+						content: '{"temp":"15C"}',
+					},
+					{
+						type: "tool_result",
+						tool_use_id: "call_2",
+						content: '{"temp":"12C"}',
+					},
+					{ type: "text", text: "summarize now" },
+				],
+			},
+		];
+
+		const openai = convertToOpenAIMessages(messages) as any[];
+		expect(openai).toHaveLength(5);
+		expect(openai[1].role).toBe("assistant");
+		expect(openai[1].tool_calls).toHaveLength(2);
+		expect(openai[1].tool_calls[0].function.name).toBe("get_weather");
+		expect(openai[2]).toMatchObject({ role: "tool", tool_call_id: "call_1" });
+		expect(openai[3]).toMatchObject({ role: "tool", tool_call_id: "call_2" });
+		expect(openai[4]).toMatchObject({ role: "user", content: "summarize now" });
+		// Ensure Gemini-specific signature metadata does not leak into OpenAI messages.
+		expect(openai[1].tool_calls[0].extra_content).toBeUndefined();
+	});
+
+	it("normalizes array-shaped tool_use input for openai replay", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "run these" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "run_commands",
+						input: ["ls -la", "pwd"] as unknown as Record<string, unknown>,
+					},
+				],
+			},
+		];
+
+		const openai = convertToOpenAIMessages(messages) as any[];
+		expect(openai[1]?.tool_calls?.[0]).toMatchObject({
+			id: "call_1",
+			type: "function",
+			function: {
+				name: "run_commands",
+				arguments: JSON.stringify({ commands: ["ls -la", "pwd"] }),
+			},
+		});
+	});
+
+	it("keeps anthropic thinking signature and cache marker behavior", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "hello" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "thinking",
+						thinking: "reasoning",
+						signature: "anthropic-sig",
+					},
+				],
+			},
+		];
+
+		const anthropic = convertToAnthropicMessages(messages, true) as any[];
+		expect(anthropic[1].content[0].type).toBe("thinking");
+		expect(anthropic[1].content[0].signature).toBe("anthropic-sig");
+	});
+
+	it("normalizes array-shaped tool_use input for anthropic replay", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "run these" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "run_commands",
+						input: ["ls -la", "pwd"] as unknown as Record<string, unknown>,
+					},
+				],
+			},
+		];
+
+		const anthropic = convertToAnthropicMessages(messages) as any[];
+		expect(anthropic[1]?.content?.[0]).toMatchObject({
+			type: "tool_use",
+			id: "call_1",
+			name: "run_commands",
+			input: {
+				commands: ["ls -la", "pwd"],
+			},
+		});
+	});
+
+	it("handles R1 interchange with tool results and reasoning_content", () => {
+		const messages: Message[] = [
+			{ role: "user", content: "check weather" },
+			{
+				role: "assistant",
+				content: [
+					{ type: "thinking", thinking: "need both cities" },
+					{
+						type: "tool_use",
+						id: "call_1",
+						name: "get_weather",
+						input: { city: "Paris" },
+					},
+					{
+						type: "tool_use",
+						id: "call_2",
+						name: "get_weather",
+						input: { city: "London" },
+					},
+				],
+			},
+			{
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: "call_1",
+						content: '{"temp":"15C"}',
+					},
+					{
+						type: "tool_result",
+						tool_use_id: "call_2",
+						content: '{"temp":"12C"}',
+					},
+				],
+			},
+		];
+
+		const r1 = convertToR1Messages(messages) as any[];
+		expect(r1[1].role).toBe("assistant");
+		expect(r1[1].tool_calls).toHaveLength(2);
+		expect(r1[1].reasoning_content).toBe("need both cities");
+		expect(r1[2]).toMatchObject({ role: "tool", tool_call_id: "call_1" });
+		expect(r1[3]).toMatchObject({ role: "tool", tool_call_id: "call_2" });
+	});
+
+	it("converts tools for all providers", () => {
+		const tools = [
+			{
+				name: "read_file",
+				description: "Read file",
+				inputSchema: {
+					type: "object",
+					properties: { path: { type: "string" } },
+				},
+			},
+		];
+
+		expect(convertToolsToOpenAI(tools)[0]).toMatchObject({
+			type: "function",
+			function: { name: "read_file", strict: true },
+		});
+		expect(convertToolsToOpenAI(tools, { strict: false })[0]).toMatchObject({
+			type: "function",
+			function: { name: "read_file", strict: false },
+		});
+		expect(convertToolsToAnthropic(tools)[0]).toMatchObject({
+			name: "read_file",
+		});
+		expect(convertToolsToGemini(tools)[0]).toMatchObject({ name: "read_file" });
+	});
+});

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

@@ -0,0 +1,167 @@
+/**
+ * Gemini Message Format Converter
+ *
+ * Converts our unified Message format to Google Gemini's Content format.
+ */
+
+import { formatFileContentBlock } from "@clinebot/shared";
+import type { Content, FunctionDeclaration, Part } from "@google/genai";
+import type {
+	ContentBlock,
+	FileContent,
+	ImageContent,
+	Message,
+	TextContent,
+	ThinkingContent,
+	ToolResultContent,
+	ToolUseContent,
+} from "../types/messages";
+import {
+	normalizeToolUseInput,
+	serializeToolResultContent,
+} from "./content-format";
+
+/**
+ * Convert messages to Gemini format
+ */
+export function convertToGeminiMessages(messages: Message[]): Content[] {
+	return messages.map(convertMessage).filter((m): m is Content => m !== null);
+}
+
+function convertMessage(message: Message): Content | null {
+	const { role, content } = message;
+
+	// Map roles: Gemini uses "user" and "model"
+	const geminiRole = role === "assistant" ? "model" : "user";
+
+	// Simple string content
+	if (typeof content === "string") {
+		return {
+			role: geminiRole,
+			parts: [{ text: content }],
+		};
+	}
+
+	// Array content
+	const parts = convertContentBlocks(content);
+	if (parts.length === 0) {
+		return null;
+	}
+
+	return {
+		role: geminiRole,
+		parts,
+	};
+}
+
+function convertContentBlocks(content: ContentBlock[]): Part[] {
+	const parts: Part[] = [];
+
+	for (const block of content) {
+		const converted = convertContentBlock(block);
+		if (converted) {
+			parts.push(converted);
+		}
+	}
+
+	return parts;
+}
+
+function convertContentBlock(block: ContentBlock): Part | null {
+	switch (block.type) {
+		case "text": {
+			const textBlock = block as TextContent;
+			const part: Part = { text: textBlock.text };
+			if (textBlock.signature) {
+				(part as any).thoughtSignature = textBlock.signature;
+			}
+			return part;
+		}
+
+		case "file": {
+			const fileBlock = block as FileContent;
+			const part: Part = {
+				text: formatFileContentBlock(fileBlock.path, fileBlock.content),
+			};
+
+			return part;
+		}
+
+		case "image": {
+			const imageBlock = block as ImageContent;
+			return {
+				inlineData: {
+					mimeType: imageBlock.mediaType,
+					data: imageBlock.data,
+				},
+			};
+		}
+
+		case "tool_use": {
+			const toolBlock = block as ToolUseContent;
+			const part: Part = {
+				functionCall: {
+					name: toolBlock.name,
+					args: normalizeToolUseInput(toolBlock.input),
+				},
+			};
+			if (toolBlock.signature) {
+				(part as any).thoughtSignature = toolBlock.signature;
+			}
+			return part;
+		}
+
+		case "tool_result": {
+			const resultBlock = block as ToolResultContent;
+			let responseContent: Record<string, unknown>;
+
+			if (typeof resultBlock.content === "string") {
+				responseContent = { result: resultBlock.content };
+			} else {
+				responseContent = {
+					result: serializeToolResultContent(resultBlock.content),
+				};
+			}
+
+			if (resultBlock.is_error) {
+				responseContent.error = true;
+			}
+
+			return {
+				functionResponse: {
+					name: resultBlock.tool_use_id, // Gemini uses the function name here
+					response: responseContent,
+				},
+			};
+		}
+
+		case "thinking": {
+			const thinkingBlock = block as ThinkingContent;
+			// Gemini uses thought: true to mark thinking blocks
+			const part = {
+				text: thinkingBlock.thinking,
+				thought: true,
+			} as Part;
+			if (thinkingBlock.signature) {
+				(part as any).thoughtSignature = thinkingBlock.signature;
+			}
+			return part;
+		}
+
+		default:
+			return null;
+	}
+}
+
+/**
+ * Convert tool definitions to Gemini format
+ */
+export function convertToolsToGemini(
+	tools: Array<{ name: string; description: string; inputSchema: unknown }>,
+): FunctionDeclaration[] {
+	return tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.inputSchema as FunctionDeclaration["parameters"],
+	}));
+}

package/src/providers/transform/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Transform Module Index
+ *
+ * Re-exports all message format converters.
+ */
+
+export {
+	type AiSdkMessage,
+	type AiSdkMessagePart,
+	toAiSdkMessages,
+} from "./ai-sdk-community-format";
+export {
+	convertToAnthropicMessages,
+	convertToolsToAnthropic,
+} from "./anthropic-format";
+export { convertToGeminiMessages, convertToolsToGemini } from "./gemini-format";
+export {
+	convertToOpenAIMessages,
+	convertToolsToOpenAI,
+	getOpenAIToolParams,
+} from "./openai-format";
+export { convertToR1Messages, type R1Message } from "./r1-format";