ruflo 3.5.1 → 3.5.3

package/src/ruvocal/src/lib/utils/sha256.ts

@@ -0,0 +1,7 @@
+export async function sha256(input: string): Promise<string> {
+	const utf8 = new TextEncoder().encode(input);
+	const hashBuffer = await crypto.subtle.digest("SHA-256", utf8);
+	const hashArray = Array.from(new Uint8Array(hashBuffer));
+	const hashHex = hashArray.map((bytes) => bytes.toString(16).padStart(2, "0")).join("");
+	return hashHex;
+}

package/src/ruvocal/src/lib/utils/stringifyError.ts

@@ -0,0 +1,12 @@
+/** Takes an unknown error and attempts to convert it to a string */
+export function stringifyError(error: unknown): string {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	if (typeof error === "object" && error !== null) {
+		// try a few common properties
+		if ("message" in error && typeof error.message === "string") return error.message;
+		if ("body" in error && typeof error.body === "string") return error.body;
+		if ("name" in error && typeof error.name === "string") return error.name;
+	}
+	return "Unknown error";
+}

package/src/ruvocal/src/lib/utils/sum.ts

@@ -0,0 +1,3 @@
+export function sum(nums: number[]): number {
+	return nums.reduce((a, b) => a + b, 0);
+}

package/src/ruvocal/src/lib/utils/template.spec.ts

@@ -0,0 +1,59 @@
+import { describe, test, expect } from "vitest";
+import { compileTemplate } from "./template";
+
+// Test data for simple templates
+const modelData = {
+	preprompt: "Hello",
+};
+
+const simpleTemplate = "Test: {{preprompt}} and {{foo}}";
+
+// Additional realistic test data for Llama 70B templates
+const messages = [
+	{ from: "user", content: "Hello there" },
+	{ from: "assistant", content: "Hi, how can I help?" },
+];
+
+// Handlebars Llama 70B Template
+const llama70bTemplateHB = `<s>{{#if preprompt}}Source: system\n\n{{preprompt}}<step>{{/if}}{{#each messages}}{{#ifUser}}Source: user\n\n{{content}}<step>{{/ifUser}}{{#ifAssistant}}Source: assistant\n\n{{content}}<step>{{/ifAssistant}}{{/each}}Source: assistant\nDestination: user\n\n`;
+
+// Expected output for Handlebars Llama 70B Template
+const expectedHB =
+	"<s>Source: system\n\nSystem Message<step>Source: user\n\nHello there<step>Source: assistant\n\nHi, how can I help?<step>Source: assistant\nDestination: user\n\n";
+
+// Jinja Llama 70B Template
+const llama70bTemplateJinja = `<s>{% if preprompt %}Source: system\n\n{{ preprompt }}<step>{% endif %}{% for message in messages %}{% if message.from == 'user' %}Source: user\n\n{{ message.content }}<step>{% elif message.from == 'assistant' %}Source: assistant\n\n{{ message.content }}<step>{% endif %}{% endfor %}Source: assistant\nDestination: user\n\n`;
+
+// Expected output for Jinja Llama 70B Template
+const expectedJinja =
+	"<s>Source: system\n\nSystem Message<step>Source: user\n\nHello there<step>Source: assistant\n\nHi, how can I help?<step>Source: assistant\nDestination: user\n\n";
+
+describe("Template Engine Rendering", () => {
+	test("should render using Handlebars fallback when no templateEngine is specified", () => {
+		const render = compileTemplate(simpleTemplate, modelData);
+		const result = render({ foo: "World" });
+		expect(result).toBe("Test: Hello and World");
+	});
+
+	test('should render using Jinja when templateEngine is set to "jinja"', () => {
+		const render = compileTemplate(simpleTemplate, modelData);
+		const result = render({ foo: "World" });
+		expect(result).toBe("Test: Hello and World");
+	});
+
+	// Realistic Llama 70B template tests
+	test("should render realistic Llama 70B template using Handlebars", () => {
+		const render = compileTemplate(llama70bTemplateHB, { preprompt: "System Message" });
+		const result = render({ messages });
+		expect(result).toBe(expectedHB);
+	});
+
+	test("should render realistic Llama 70B template using Jinja", () => {
+		const render = compileTemplate(llama70bTemplateJinja, {
+			preprompt: "System Message",
+		});
+		const result = render({ messages });
+		// Trim both outputs to account for whitespace differences in Jinja engine
+		expect(result.trim()).toBe(expectedJinja.trim());
+	});
+});

package/src/ruvocal/src/lib/utils/template.ts

@@ -0,0 +1,53 @@
+import type { Message } from "$lib/types/Message";
+import Handlebars from "handlebars";
+import { Template } from "@huggingface/jinja";
+import { logger } from "$lib/server/logger";
+
+// Register Handlebars helpers
+Handlebars.registerHelper("ifUser", function (this: Pick<Message, "from" | "content">, options) {
+	if (this.from == "user") return options.fn(this);
+});
+
+Handlebars.registerHelper(
+	"ifAssistant",
+	function (this: Pick<Message, "from" | "content">, options) {
+		if (this.from == "assistant") return options.fn(this);
+	}
+);
+
+// Updated compileTemplate to try Jinja and fallback to Handlebars if Jinja fails
+export function compileTemplate<T>(
+	input: string,
+	model: { preprompt: string; templateEngine?: string }
+) {
+	let jinjaTemplate: Template | undefined;
+	try {
+		// Try to compile with Jinja
+		jinjaTemplate = new Template(input);
+	} catch (e) {
+		// logger.error(e, "Could not compile with Jinja");
+		// Could not compile with Jinja
+		jinjaTemplate = undefined;
+	}
+
+	const hbTemplate = Handlebars.compile<T>(input, {
+		knownHelpers: { ifUser: true, ifAssistant: true },
+		knownHelpersOnly: true,
+		noEscape: true,
+		strict: true,
+		preventIndent: true,
+	});
+
+	return function render(inputs: T) {
+		if (jinjaTemplate) {
+			try {
+				return jinjaTemplate.render({ ...model, ...inputs });
+			} catch (e) {
+				logger.error(e, "Could not render with Jinja");
+				// Fallback to Handlebars if Jinja rendering fails
+				return hbTemplate({ ...model, ...inputs });
+			}
+		}
+		return hbTemplate({ ...model, ...inputs });
+	};
+}

package/src/ruvocal/src/lib/utils/timeout.ts

@@ -0,0 +1,9 @@
+export const timeout = <T>(prom: Promise<T>, time: number): Promise<T> => {
+	let timer: NodeJS.Timeout;
+	return Promise.race([
+		prom,
+		new Promise<T>((_, reject) => {
+			timer = setTimeout(() => reject(new Error(`Timeout after ${time / 1000} seconds`)), time);
+		}),
+	]).finally(() => clearTimeout(timer));
+};

package/src/ruvocal/src/lib/utils/toolProgress.spec.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "vitest";
+
+import { MessageToolUpdateType, MessageUpdateType } from "$lib/types/MessageUpdate";
+import { formatToolProgressLabel } from "./toolProgress";
+
+describe("formatToolProgressLabel", () => {
+	test("returns empty string when progress is missing", () => {
+		expect(formatToolProgressLabel(undefined)).toBe("");
+	});
+
+	test("formats progress with message", () => {
+		expect(
+			formatToolProgressLabel({
+				type: MessageUpdateType.Tool,
+				subtype: MessageToolUpdateType.Progress,
+				uuid: "tool-1",
+				progress: 3,
+				total: 10,
+				message: "Indexing",
+			})
+		).toBe("Indexing (3/10)");
+	});
+
+	test("formats progress without message", () => {
+		expect(
+			formatToolProgressLabel({
+				type: MessageUpdateType.Tool,
+				subtype: MessageToolUpdateType.Progress,
+				uuid: "tool-2",
+				progress: 7,
+			})
+		).toBe("Progress: 7");
+	});
+
+	test("formats progress with message and no total", () => {
+		expect(
+			formatToolProgressLabel({
+				type: MessageUpdateType.Tool,
+				subtype: MessageToolUpdateType.Progress,
+				uuid: "tool-3",
+				progress: 12,
+				message: "ZeroGPU Initializing xxx",
+			})
+		).toBe("ZeroGPU Initializing xxx (12)");
+	});
+});

package/src/ruvocal/src/lib/utils/toolProgress.ts

@@ -0,0 +1,11 @@
+import type { MessageToolProgressUpdate } from "$lib/types/MessageUpdate";
+
+export function formatToolProgressLabel(progress?: MessageToolProgressUpdate): string {
+	if (!progress) return "";
+	const total = typeof progress.total === "number" ? `/${progress.total}` : "";
+	const value = `${progress.progress}${total}`;
+	if (progress.message && progress.message.trim().length > 0) {
+		return `${progress.message} (${value})`;
+	}
+	return `Progress: ${value}`;
+}

package/src/ruvocal/src/lib/utils/tree/addChildren.spec.ts

@@ -0,0 +1,102 @@
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+
+import { insertLegacyConversation, insertSideBranchesConversation } from "./treeHelpers.spec";
+import { addChildren } from "./addChildren";
+import type { Message } from "$lib/types/Message";
+
+const newMessage: Omit<Message, "id"> = {
+	content: "new message",
+	from: "user",
+};
+
+Object.freeze(newMessage);
+
+describe("addChildren", async () => {
+	it("should let you append on legacy conversations", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const convLength = conv.messages.length;
+
+		addChildren(conv, newMessage, conv.messages[conv.messages.length - 1].id);
+		expect(conv.messages.length).toEqual(convLength + 1);
+	});
+	it("should not let you create branches on legacy conversations", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addChildren(conv, newMessage, conv.messages[0].id)).toThrow();
+	});
+	it("should not let you create a message that already exists", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const messageThatAlreadyExists: Message = {
+			id: conv.messages[0].id,
+			content: "new message",
+			from: "user",
+		};
+
+		expect(() => addChildren(conv, messageThatAlreadyExists, conv.messages[0].id)).toThrow();
+	});
+	it("should let you create branches on conversations with subtrees", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const nChildren = conv.messages[0].children?.length;
+		if (!nChildren) throw new Error("No children found");
+		addChildren(conv, newMessage, conv.messages[0].id);
+		expect(conv.messages[0].children?.length).toEqual(nChildren + 1);
+	});
+
+	it("should let you create a new leaf", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const parentId = conv.messages[conv.messages.length - 1].id;
+		const nChildren = conv.messages[conv.messages.length - 1].children?.length;
+
+		if (nChildren === undefined) throw new Error("No children found");
+		expect(nChildren).toEqual(0);
+
+		addChildren(conv, newMessage, parentId);
+		expect(conv.messages[conv.messages.length - 2].children?.length).toEqual(nChildren + 1);
+	});
+
+	it("should let you append to an empty conversation without specifying a parentId", async () => {
+		const conv = {
+			_id: new ObjectId(),
+			rootMessageId: undefined,
+			messages: [] as Message[],
+		};
+
+		addChildren(conv, newMessage);
+		expect(conv.messages.length).toEqual(1);
+		expect(conv.rootMessageId).toEqual(conv.messages[0].id);
+	});
+
+	it("should throw if you don't specify a parentId in a conversation with messages", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addChildren(conv, newMessage)).toThrow();
+	});
+
+	it("should return the id of the new message", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(addChildren(conv, newMessage, conv.messages[conv.messages.length - 1].id)).toEqual(
+			conv.messages[conv.messages.length - 1].id
+		);
+	});
+});

package/src/ruvocal/src/lib/utils/tree/addChildren.ts

@@ -0,0 +1,48 @@
+import { v4 } from "uuid";
+import type { Tree, TreeId, NewNode, TreeNode } from "./tree";
+
+export function addChildren<T>(conv: Tree<T>, message: NewNode<T>, parentId?: TreeId): TreeId {
+	// if this is the first message we just push it
+	if (conv.messages.length === 0) {
+		const messageId = v4();
+		conv.rootMessageId = messageId;
+		conv.messages.push({
+			...message,
+			ancestors: [],
+			id: messageId,
+		} as TreeNode<T>);
+		return messageId;
+	}
+
+	if (!parentId) {
+		throw new Error("You need to specify a parentId if this is not the first message");
+	}
+
+	const messageId = v4();
+	if (!conv.rootMessageId) {
+		// if there is no parentId we just push the message
+		if (!!parentId && parentId !== conv.messages[conv.messages.length - 1].id) {
+			throw new Error("This is a legacy conversation, you can only append to the last message");
+		}
+		conv.messages.push({ ...message, id: messageId } as TreeNode<T>);
+		return messageId;
+	}
+
+	const ancestors = [...(conv.messages.find((m) => m.id === parentId)?.ancestors ?? []), parentId];
+	conv.messages.push({
+		...message,
+		ancestors,
+		id: messageId,
+		children: [],
+	} as TreeNode<T>);
+
+	const parent = conv.messages.find((m) => m.id === parentId);
+
+	if (parent) {
+		if (parent.children) {
+			parent.children.push(messageId);
+		} else parent.children = [messageId];
+	}
+
+	return messageId;
+}

package/src/ruvocal/src/lib/utils/tree/addSibling.spec.ts

@@ -0,0 +1,81 @@
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+
+import { insertLegacyConversation, insertSideBranchesConversation } from "./treeHelpers.spec";
+import type { Message } from "$lib/types/Message";
+import { addSibling } from "./addSibling";
+import type { Conversation } from "$lib/types/Conversation";
+
+const newMessage = {
+	content: "new message",
+	from: "user" as const,
+};
+
+Object.freeze(newMessage);
+
+describe("addSibling", async () => {
+	it("should fail on empty conversations", () => {
+		const conv = {
+			_id: new ObjectId(),
+			rootMessageId: undefined,
+			messages: [] as Message[],
+		} satisfies Pick<Conversation, "_id" | "rootMessageId" | "messages">;
+
+		expect(() => addSibling(conv, newMessage, "not-a-real-id-test")).toThrow(
+			"Cannot add a sibling to an empty conversation"
+		);
+	});
+
+	it("should fail on legacy conversations", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addSibling(conv, newMessage, conv.messages[0].id)).toThrow(
+			"Cannot add a sibling to a legacy conversation"
+		);
+	});
+
+	it("should fail if the sibling message doesn't exist", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		expect(() => addSibling(conv, newMessage, "not-a-real-id-test")).toThrow(
+			"The sibling message doesn't exist"
+		);
+	});
+
+	// TODO: This behaviour should be fixed, we do not need to fail on the root message.
+	it("should fail if the sibling message is the root message", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+		if (!conv.rootMessageId) throw new Error("Root message not found");
+
+		expect(() => addSibling(conv, newMessage, conv.rootMessageId as Message["id"])).toThrow(
+			"The sibling message is the root message, therefore we can't add a sibling"
+		);
+	});
+
+	it("should add a sibling to a message", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		// add sibling and check children count for parnets
+
+		const nChildren = conv.messages[1].children?.length;
+		const siblingId = addSibling(conv, newMessage, conv.messages[2].id);
+		const nChildrenNew = conv.messages[1].children?.length;
+
+		if (!nChildren) throw new Error("No children found");
+
+		expect(nChildrenNew).toBe(nChildren + 1);
+
+		// make sure siblings have the same ancestors
+		const sibling = conv.messages.find((m) => m.id === siblingId);
+		expect(sibling?.ancestors).toEqual(conv.messages[2].ancestors);
+	});
+});

package/src/ruvocal/src/lib/utils/tree/addSibling.ts

@@ -0,0 +1,41 @@
+import { v4 } from "uuid";
+import type { Tree, TreeId, NewNode, TreeNode } from "./tree";
+
+export function addSibling<T>(conv: Tree<T>, message: NewNode<T>, siblingId: TreeId): TreeId {
+	if (conv.messages.length === 0) {
+		throw new Error("Cannot add a sibling to an empty conversation");
+	}
+	if (!conv.rootMessageId) {
+		throw new Error("Cannot add a sibling to a legacy conversation");
+	}
+
+	const sibling = conv.messages.find((m) => m.id === siblingId);
+
+	if (!sibling) {
+		throw new Error("The sibling message doesn't exist");
+	}
+
+	if (!sibling.ancestors || sibling.ancestors?.length === 0) {
+		throw new Error("The sibling message is the root message, therefore we can't add a sibling");
+	}
+
+	const messageId = v4();
+
+	conv.messages.push({
+		...message,
+		id: messageId,
+		ancestors: sibling.ancestors,
+		children: [],
+	} as TreeNode<T>);
+
+	const nearestAncestorId = sibling.ancestors[sibling.ancestors.length - 1];
+	const nearestAncestor = conv.messages.find((m) => m.id === nearestAncestorId);
+
+	if (nearestAncestor) {
+		if (nearestAncestor.children) {
+			nearestAncestor.children.push(messageId);
+		} else nearestAncestor.children = [messageId];
+	}
+
+	return messageId;
+}

package/src/ruvocal/src/lib/utils/tree/buildSubtree.spec.ts

@@ -0,0 +1,110 @@
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+
+import {
+	insertLegacyConversation,
+	insertLinearBranchConversation,
+	insertSideBranchesConversation,
+} from "./treeHelpers.spec";
+import { buildSubtree } from "./buildSubtree";
+
+describe("buildSubtree", () => {
+	it("a subtree in a legacy conversation should be just a slice", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		// check middle
+		const id = conv.messages[2].id;
+		const subtree = buildSubtree(conv, id);
+		expect(subtree).toEqual(conv.messages.slice(0, 3));
+
+		// check zero
+		const id2 = conv.messages[0].id;
+		const subtree2 = buildSubtree(conv, id2);
+		expect(subtree2).toEqual(conv.messages.slice(0, 1));
+
+		//check full length
+		const id3 = conv.messages[conv.messages.length - 1].id;
+		const subtree3 = buildSubtree(conv, id3);
+		expect(subtree3).toEqual(conv.messages);
+	});
+
+	it("a subtree in a linear branch conversation should be the ancestors and the message", async () => {
+		const convId = await insertLinearBranchConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		// check middle
+		const id = conv.messages[1].id;
+		const subtree = buildSubtree(conv, id);
+		expect(subtree).toEqual([conv.messages[0], conv.messages[1]]);
+
+		// check zero
+		const id2 = conv.messages[0].id;
+		const subtree2 = buildSubtree(conv, id2);
+		expect(subtree2).toEqual([conv.messages[0]]);
+
+		//check full length
+		const id3 = conv.messages[conv.messages.length - 1].id;
+		const subtree3 = buildSubtree(conv, id3);
+		expect(subtree3).toEqual(conv.messages);
+	});
+
+	it("should throw an error if the message is not found", async () => {
+		const convId = await insertLinearBranchConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const id = "not-a-real-id-test";
+
+		expect(() => buildSubtree(conv, id)).toThrow("Message not found");
+	});
+
+	it("should throw an error if the ancestor is not found", async () => {
+		const convId = await insertLinearBranchConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const id = "1-1-1-1-2";
+
+		conv.messages[1].ancestors = ["not-a-real-id-test"];
+
+		expect(() => buildSubtree(conv, id)).toThrow("Ancestor not found");
+	});
+
+	it("should work on empty conversations", () => {
+		const conv = {
+			_id: new ObjectId(),
+			rootMessageId: undefined,
+			messages: [],
+		};
+
+		const subtree = buildSubtree(conv, "not-a-real-id-test");
+		expect(subtree).toEqual([]);
+	});
+
+	it("should work for conversation with subtrees", async () => {
+		const convId = await insertSideBranchesConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const subtree = buildSubtree(conv, "1-1-1-1-2");
+		expect(subtree).toEqual([conv.messages[0], conv.messages[1]]);
+
+		const subtree2 = buildSubtree(conv, "1-1-1-1-4");
+		expect(subtree2).toEqual([
+			conv.messages[0],
+			conv.messages[1],
+			conv.messages[2],
+			conv.messages[3],
+		]);
+
+		const subtree3 = buildSubtree(conv, "1-1-1-1-6");
+		expect(subtree3).toEqual([conv.messages[0], conv.messages[4], conv.messages[5]]);
+
+		const subtree4 = buildSubtree(conv, "1-1-1-1-7");
+		expect(subtree4).toEqual([conv.messages[0], conv.messages[4], conv.messages[6]]);
+	});
+});

package/src/ruvocal/src/lib/utils/tree/buildSubtree.ts

@@ -0,0 +1,24 @@
+import type { Tree, TreeId, TreeNode } from "./tree";
+
+export function buildSubtree<T>(conv: Tree<T>, id: TreeId): TreeNode<T>[] {
+	if (!conv.rootMessageId) {
+		if (conv.messages.length === 0) return [];
+		// legacy conversation slice up to id
+		const index = conv.messages.findIndex((m) => m.id === id);
+		if (index === -1) throw new Error("Message not found");
+		return conv.messages.slice(0, index + 1);
+	} else {
+		// find the message with the right id then create the ancestor tree
+		const message = conv.messages.find((m) => m.id === id);
+		if (!message) throw new Error("Message not found");
+
+		return [
+			...(message.ancestors?.map((ancestorId) => {
+				const ancestor = conv.messages.find((m) => m.id === ancestorId);
+				if (!ancestor) throw new Error("Ancestor not found");
+				return ancestor;
+			}) ?? []),
+			message,
+		];
+	}
+}

package/src/ruvocal/src/lib/utils/tree/convertLegacyConversation.spec.ts

@@ -0,0 +1,31 @@
+import { collections } from "$lib/server/database";
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+
+import { convertLegacyConversation } from "./convertLegacyConversation";
+import { insertLegacyConversation } from "./treeHelpers.spec";
+
+describe("convertLegacyConversation", () => {
+	it("should convert a legacy conversation", async () => {
+		const convId = await insertLegacyConversation();
+		const conv = await collections.conversations.findOne({ _id: new ObjectId(convId) });
+		if (!conv) throw new Error("Conversation not found");
+
+		const newConv = convertLegacyConversation(conv);
+
+		expect(newConv.rootMessageId).toBe(newConv.messages[0].id);
+		expect(newConv.messages[0].ancestors).toEqual([]);
+		expect(newConv.messages[1].ancestors).toEqual([newConv.messages[0].id]);
+		expect(newConv.messages[0].children).toEqual([newConv.messages[1].id]);
+	});
+	it("should work on empty conversations", async () => {
+		const conv = {
+			_id: new ObjectId(),
+			rootMessageId: undefined,
+			messages: [],
+		};
+		const newConv = convertLegacyConversation(conv);
+		expect(newConv.rootMessageId).toBe(undefined);
+		expect(newConv.messages).toEqual([]);
+	});
+});