@clinebot/llms 0.0.20 → 0.0.21

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

@@ -1,73 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,230 +0,0 @@
-/**
- * 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 userMessageIndices = messages.reduce<number[]>(
-		(indices, message, index) => {
-			if (message.role === "user") {
-				indices.push(index);
-			}
-			return indices;
-		},
-		[],
-	);
-	const cacheableMessageIndices = enableCaching
-		? new Set(userMessageIndices.slice(-2))
-		: new Set<number>();
-	const result: AnthropicMessage[] = [];
-
-	for (const [index, message] of messages.entries()) {
-		const converted = convertMessage(
-			message,
-			cacheableMessageIndices.has(index),
-		);
-		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

@@ -1,34 +0,0 @@
-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");
-}