ruflo 3.5.2 → 3.5.4

package/src/ruvocal/src/lib/server/database.ts

@@ -0,0 +1,145 @@
+/**
+ * RuVocal Database — self-contained RVF document store.
+ *
+ * Zero external dependencies. All data persisted to a single
+ * RVF JSON file on disk. MongoDB Collection interface preserved
+ * so all 56 importing files work unchanged.
+ */
+
+import type { Conversation } from "$lib/types/Conversation";
+import type { SharedConversation } from "$lib/types/SharedConversation";
+import type { AbortedGeneration } from "$lib/types/AbortedGeneration";
+import type { Settings } from "$lib/types/Settings";
+import type { User } from "$lib/types/User";
+import type { MessageEvent } from "$lib/types/MessageEvent";
+import type { Session } from "$lib/types/Session";
+import type { Assistant } from "$lib/types/Assistant";
+import type { Report } from "$lib/types/Report";
+import type { ConversationStats } from "$lib/types/ConversationStats";
+import type { MigrationResult } from "$lib/types/MigrationResult";
+import type { Semaphore } from "$lib/types/Semaphore";
+import type { AssistantStats } from "$lib/types/AssistantStats";
+import type { TokenCache } from "$lib/types/TokenCache";
+import type { ConfigKey } from "$lib/types/ConfigKey";
+
+import { building } from "$app/environment";
+import { onExit } from "./exitHandler";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync, mkdirSync } from "fs";
+
+import {
+	RvfCollection,
+	RvfGridFSBucket,
+	initRvfStore,
+	flushToDisk,
+} from "./database/rvf";
+
+export const CONVERSATION_STATS_COLLECTION = "conversations.stats";
+
+export class Database {
+	private static instance: Database;
+	private initialized = false;
+
+	private async init() {
+		const dbFolder =
+			process.env.RVF_DB_PATH ||
+			join(dirname(fileURLToPath(import.meta.url)), "../../../db");
+
+		if (!existsSync(dbFolder)) {
+			mkdirSync(dbFolder, { recursive: true });
+		}
+
+		const dbPath = join(dbFolder, "ruvocal.rvf.json");
+
+		console.log(`[RuVocal] Database: ${dbPath}`);
+		initRvfStore(dbPath);
+		this.initialized = true;
+
+		// Flush to disk on exit
+		onExit(async () => {
+			console.log("[RuVocal] Flushing database to disk");
+			flushToDisk();
+		});
+	}
+
+	public static async getInstance(): Promise<Database> {
+		if (!Database.instance) {
+			Database.instance = new Database();
+			await Database.instance.init();
+		}
+		return Database.instance;
+	}
+
+	public getClient() {
+		if (!this.initialized) {
+			throw new Error("Database not initialized");
+		}
+		return {}; // No external client — self-contained
+	}
+
+	public getCollections() {
+		if (!this.initialized) {
+			throw new Error("Database not initialized");
+		}
+
+		const conversations = new RvfCollection<Conversation>("conversations");
+		const settings = new RvfCollection<Settings>("settings");
+		const users = new RvfCollection<User>("users");
+		const sessions = new RvfCollection<Session>("sessions");
+		const messageEvents = new RvfCollection<MessageEvent>("messageEvents");
+		const abortedGenerations = new RvfCollection<AbortedGeneration>("abortedGenerations");
+		const semaphores = new RvfCollection<Semaphore>("semaphores");
+		const tokenCaches = new RvfCollection<TokenCache>("tokens");
+		const configCollection = new RvfCollection<ConfigKey>("config");
+		const migrationResults = new RvfCollection<MigrationResult>("migrationResults");
+		const sharedConversations = new RvfCollection<SharedConversation>("sharedConversations");
+		const assistants = new RvfCollection<Assistant>("assistants");
+		const assistantStats = new RvfCollection<AssistantStats>("assistants.stats");
+		const conversationStats = new RvfCollection<ConversationStats>(CONVERSATION_STATS_COLLECTION);
+		const reports = new RvfCollection<Report>("reports");
+		const tools = new RvfCollection<Record<string, unknown>>("tools");
+		const bucket = new RvfGridFSBucket();
+
+		return {
+			conversations,
+			conversationStats,
+			assistants,
+			assistantStats,
+			reports,
+			sharedConversations,
+			abortedGenerations,
+			settings,
+			users,
+			sessions,
+			messageEvents,
+			bucket,
+			migrationResults,
+			semaphores,
+			tokenCaches,
+			tools,
+			config: configCollection,
+		};
+	}
+}
+
+export let collections: ReturnType<typeof Database.prototype.getCollections>;
+
+export const ready = (async () => {
+	if (!building) {
+		const db = await Database.getInstance();
+		collections = db.getCollections();
+	} else {
+		collections = {} as unknown as ReturnType<typeof Database.prototype.getCollections>;
+	}
+})();
+
+export async function getCollectionsEarly(): Promise<
+	ReturnType<typeof Database.prototype.getCollections>
+> {
+	await ready;
+	if (!collections) {
+		throw new Error("Database not initialized");
+	}
+	return collections;
+}

package/src/ruvocal/src/lib/server/endpoints/document.ts

@@ -0,0 +1,68 @@
+import type { MessageFile } from "$lib/types/Message";
+import { z } from "zod";
+
+export interface FileProcessorOptions<TMimeType extends string = string> {
+	supportedMimeTypes: TMimeType[];
+	maxSizeInMB: number;
+}
+
+// Removed unused ImageProcessor type alias
+
+export const createDocumentProcessorOptionsValidator = <TMimeType extends string = string>(
+	defaults: FileProcessorOptions<TMimeType>
+) => {
+	return z
+		.object({
+			supportedMimeTypes: z
+				.array(
+					z.enum<string, [TMimeType, ...TMimeType[]]>([
+						defaults.supportedMimeTypes[0],
+						...defaults.supportedMimeTypes.slice(1),
+					])
+				)
+				.default(defaults.supportedMimeTypes),
+			maxSizeInMB: z.number().positive().default(defaults.maxSizeInMB),
+		})
+		.default(defaults);
+};
+
+// Removed unused DocumentProcessor type alias
+
+export type AsyncDocumentProcessor<TMimeType extends string = string> = (
+	file: MessageFile
+) => Promise<{
+	file: Buffer;
+	mime: TMimeType;
+}>;
+
+export function makeDocumentProcessor<TMimeType extends string = string>(
+	options: FileProcessorOptions<TMimeType>
+): AsyncDocumentProcessor<TMimeType> {
+	return async (file) => {
+		const { supportedMimeTypes, maxSizeInMB } = options;
+		const { mime, value } = file;
+
+		const buffer = Buffer.from(value, "base64");
+		const tooLargeInBytes = buffer.byteLength > maxSizeInMB * 1000 * 1000;
+
+		if (tooLargeInBytes) {
+			throw Error("Document is too large");
+		}
+
+		const outputMime = validateMimeType(supportedMimeTypes, mime);
+		return { file: buffer, mime: outputMime };
+	};
+}
+
+const validateMimeType = <T extends readonly string[]>(
+	supportedMimes: T,
+	mime: string
+): T[number] => {
+	if (!supportedMimes.includes(mime)) {
+		const supportedMimesStr = supportedMimes.join(", ");
+
+		throw Error(`Mimetype "${mime}" not found in supported mimes: ${supportedMimesStr}`);
+	}
+
+	return mime;
+};

package/src/ruvocal/src/lib/server/endpoints/endpoints.ts

@@ -0,0 +1,43 @@
+import type { Conversation } from "$lib/types/Conversation";
+import type { Message } from "$lib/types/Message";
+import type {
+	TextGenerationStreamOutput,
+	TextGenerationStreamToken,
+	InferenceProvider,
+} from "@huggingface/inference";
+import { z } from "zod";
+import { endpointOAIParametersSchema, endpointOai } from "./openai/endpointOai";
+import type { Model } from "$lib/types/Model";
+import type { ObjectId } from "mongodb";
+
+export type EndpointMessage = Omit<Message, "id">;
+
+// parameters passed when generating text
+export interface EndpointParameters {
+	messages: EndpointMessage[];
+	preprompt?: Conversation["preprompt"];
+	generateSettings?: Partial<Model["parameters"]>;
+	isMultimodal?: boolean;
+	conversationId?: ObjectId;
+	locals: App.Locals | undefined;
+	abortSignal?: AbortSignal;
+	/** Inference provider preference: "auto", "fastest", "cheapest", or a specific provider name */
+	provider?: string;
+}
+
+export type TextGenerationStreamOutputSimplified = TextGenerationStreamOutput & {
+	token: TextGenerationStreamToken;
+	routerMetadata?: { route?: string; model?: string; provider?: InferenceProvider };
+};
+// type signature for the endpoint
+export type Endpoint = (
+	params: EndpointParameters
+) => Promise<AsyncGenerator<TextGenerationStreamOutputSimplified, void, void>>;
+
+// list of all endpoint generators
+export const endpoints = {
+	openai: endpointOai,
+};
+
+export const endpointSchema = z.discriminatedUnion("type", [endpointOAIParametersSchema]);
+export default endpoints;

package/src/ruvocal/src/lib/server/endpoints/images.ts

@@ -0,0 +1,211 @@
+import type { Sharp } from "sharp";
+import sharp from "sharp";
+import type { MessageFile } from "$lib/types/Message";
+import { z, type util } from "zod";
+
+export interface ImageProcessorOptions<TMimeType extends string = string> {
+	supportedMimeTypes: TMimeType[];
+	preferredMimeType: TMimeType;
+	maxSizeInMB: number;
+	maxWidth: number;
+	maxHeight: number;
+}
+export type ImageProcessor<TMimeType extends string = string> = (file: MessageFile) => Promise<{
+	image: Buffer;
+	mime: TMimeType;
+}>;
+
+export function createImageProcessorOptionsValidator<TMimeType extends string = string>(
+	defaults: ImageProcessorOptions<TMimeType>
+) {
+	return z
+		.object({
+			supportedMimeTypes: z
+				.array(
+					z.enum<string, [TMimeType, ...TMimeType[]]>([
+						defaults.supportedMimeTypes[0],
+						...defaults.supportedMimeTypes.slice(1),
+					])
+				)
+				.default(defaults.supportedMimeTypes),
+			preferredMimeType: z
+				.enum([defaults.supportedMimeTypes[0], ...defaults.supportedMimeTypes.slice(1)])
+				.default(defaults.preferredMimeType as util.noUndefined<TMimeType>),
+			maxSizeInMB: z.number().positive().default(defaults.maxSizeInMB),
+			maxWidth: z.number().int().positive().default(defaults.maxWidth),
+			maxHeight: z.number().int().positive().default(defaults.maxHeight),
+		})
+		.default(defaults);
+}
+
+export function makeImageProcessor<TMimeType extends string = string>(
+	options: ImageProcessorOptions<TMimeType>
+): ImageProcessor<TMimeType> {
+	return async (file) => {
+		const { supportedMimeTypes, preferredMimeType, maxSizeInMB, maxWidth, maxHeight } = options;
+		const { mime, value } = file;
+
+		const buffer = Buffer.from(value, "base64");
+		let sharpInst = sharp(buffer);
+
+		const metadata = await sharpInst.metadata();
+		if (!metadata) throw Error("Failed to read image metadata");
+		const { width, height } = metadata;
+		if (width === undefined || height === undefined) throw Error("Failed to read image size");
+
+		const tooLargeInSize = width > maxWidth || height > maxHeight;
+		const tooLargeInBytes = buffer.byteLength > maxSizeInMB * 1000 * 1000;
+
+		const outputMime = chooseMimeType(supportedMimeTypes, preferredMimeType, mime, {
+			preferSizeReduction: tooLargeInBytes,
+		});
+
+		// Resize if necessary
+		if (tooLargeInSize || tooLargeInBytes) {
+			const size = chooseImageSize({
+				mime: outputMime,
+				width,
+				height,
+				maxWidth,
+				maxHeight,
+				maxSizeInMB,
+			});
+			if (size.width !== width || size.height !== height) {
+				sharpInst = resizeImage(sharpInst, size.width, size.height);
+			}
+		}
+
+		// Convert format if necessary
+		// We always want to convert the image when the file was too large in bytes
+		// so we can guarantee that ideal options are used, which are expected when
+		// choosing the image size
+		if (outputMime !== mime || tooLargeInBytes) {
+			sharpInst = convertImage(sharpInst, outputMime);
+		}
+
+		const processedImage = await sharpInst.toBuffer();
+		return { image: processedImage, mime: outputMime };
+	};
+}
+
+const outputFormats = ["png", "jpeg", "webp", "avif", "tiff", "gif"] as const;
+type OutputImgFormat = (typeof outputFormats)[number];
+const isOutputFormat = (format: string): format is (typeof outputFormats)[number] =>
+	outputFormats.includes(format as OutputImgFormat);
+
+export function convertImage(sharpInst: Sharp, outputMime: string): Sharp {
+	const [type, format] = outputMime.split("/");
+	if (type !== "image") throw Error(`Requested non-image mime type: ${outputMime}`);
+	if (!isOutputFormat(format)) {
+		throw Error(`Requested to convert to an unsupported format: ${format}`);
+	}
+
+	return sharpInst[format]();
+}
+
+// heic/heif requires proprietary license
+// TODO: blocking heif may be incorrect considering it also supports av1, so we should instead
+// detect the compression method used via sharp().metadata().compression
+// TODO: consider what to do about animated formats: apng, gif, animated webp, ...
+const blocklistedMimes = ["image/heic", "image/heif"];
+
+/** Sorted from largest to smallest */
+const mimesBySizeDesc = [
+	"image/png",
+	"image/tiff",
+	"image/gif",
+	"image/jpeg",
+	"image/webp",
+	"image/avif",
+];
+
+/**
+ * Defaults to preferred format or uses existing mime if supported
+ * When preferSizeReduction is true, it will choose the smallest format that is supported
+ **/
+function chooseMimeType<T extends readonly string[]>(
+	supportedMimes: T,
+	preferredMime: string,
+	mime: string,
+	{ preferSizeReduction }: { preferSizeReduction: boolean }
+): T[number] {
+	if (!supportedMimes.includes(preferredMime)) {
+		const supportedMimesStr = supportedMimes.join(", ");
+		throw Error(
+			`Preferred format "${preferredMime}" not found in supported mimes: ${supportedMimesStr}`
+		);
+	}
+
+	const [type] = mime.split("/");
+	if (type !== "image") throw Error(`Received non-image mime type: ${mime}`);
+
+	if (supportedMimes.includes(mime) && !preferSizeReduction) return mime;
+
+	if (blocklistedMimes.includes(mime)) throw Error(`Received blocklisted mime type: ${mime}`);
+
+	const smallestMime = mimesBySizeDesc.findLast((m) => supportedMimes.includes(m));
+	return smallestMime ?? preferredMime;
+}
+
+interface ImageSizeOptions {
+	mime: string;
+	width: number;
+	height: number;
+	maxWidth: number;
+	maxHeight: number;
+	maxSizeInMB: number;
+}
+
+/** Resizes the image to fit within the specified size in MB by guessing the output size */
+export function chooseImageSize({
+	mime,
+	width,
+	height,
+	maxWidth,
+	maxHeight,
+	maxSizeInMB,
+}: ImageSizeOptions): { width: number; height: number } {
+	const biggestDiscrepency = Math.max(1, width / maxWidth, height / maxHeight);
+
+	let selectedWidth = Math.ceil(width / biggestDiscrepency);
+	let selectedHeight = Math.ceil(height / biggestDiscrepency);
+
+	do {
+		const estimatedSize = estimateImageSizeInBytes(mime, selectedWidth, selectedHeight);
+		if (estimatedSize < maxSizeInMB * 1024 * 1024) {
+			return { width: selectedWidth, height: selectedHeight };
+		}
+		selectedWidth = Math.floor(selectedWidth / 1.1);
+		selectedHeight = Math.floor(selectedHeight / 1.1);
+	} while (selectedWidth > 1 && selectedHeight > 1);
+
+	throw Error(`Failed to resize image to fit within ${maxSizeInMB}MB`);
+}
+
+const mimeToCompressionRatio: Record<string, number> = {
+	"image/png": 1 / 2,
+	"image/jpeg": 1 / 10,
+	"image/webp": 1 / 4,
+	"image/avif": 1 / 5,
+	"image/tiff": 1,
+	"image/gif": 1 / 5,
+};
+
+/**
+ * Guesses the side of an image in MB based on its format and dimensions
+ * Should guess the worst case
+ **/
+function estimateImageSizeInBytes(mime: string, width: number, height: number): number {
+	const compressionRatio = mimeToCompressionRatio[mime];
+	if (!compressionRatio) throw Error(`Unsupported image format: ${mime}`);
+
+	const bitsPerPixel = 32; // Assuming 32-bit color depth for 8-bit R G B A
+	const bytesPerPixel = bitsPerPixel / 8;
+	const uncompressedSize = width * height * bytesPerPixel;
+
+	return uncompressedSize * compressionRatio;
+}
+
+export function resizeImage(sharpInst: Sharp, maxWidth: number, maxHeight: number): Sharp {
+	return sharpInst.resize({ width: maxWidth, height: maxHeight, fit: "inside" });
+}