ruflo 3.5.2 → 3.5.3

package/src/ruvocal/src/lib/types/Semaphore.ts

@@ -0,0 +1,19 @@
+import type { Timestamps } from "./Timestamps";
+
+export interface Semaphore extends Timestamps {
+	key: string;
+	deleteAt: Date;
+}
+
+export enum Semaphores {
+	CONVERSATION_STATS = "conversation.stats",
+	CONFIG_UPDATE = "config.update",
+	MIGRATION = "migration",
+	TEST_MIGRATION = "test.migration",
+	/**
+	 * Note this lock name is used as `${Semaphores.OAUTH_TOKEN_REFRESH}:${sessionId}`
+	 *
+	 * not a global lock, but a lock for each session
+	 */
+	OAUTH_TOKEN_REFRESH = "oauth.token.refresh",
+}

package/src/ruvocal/src/lib/types/Session.ts

@@ -0,0 +1,22 @@
+import type { ObjectId } from "bson";
+import type { Timestamps } from "./Timestamps";
+import type { User } from "./User";
+
+export interface Session extends Timestamps {
+	_id: ObjectId;
+	sessionId: string;
+	userId: User["_id"];
+	userAgent?: string;
+	ip?: string;
+	expiresAt: Date;
+	admin?: boolean;
+	coupledCookieHash?: string;
+
+	oauth?: {
+		token: {
+			value: string;
+			expiresAt: Date;
+		};
+		refreshToken?: string;
+	};
+}

package/src/ruvocal/src/lib/types/Settings.ts

@@ -0,0 +1,86 @@
+import { defaultModel } from "$lib/server/models";
+import type { Timestamps } from "./Timestamps";
+import type { User } from "./User";
+
+export type StreamingMode = "raw" | "smooth";
+
+export interface Settings extends Timestamps {
+	userId?: User["_id"];
+	sessionId?: string;
+
+	shareConversationsWithModelAuthors: boolean;
+	/** One-time welcome modal acknowledgement */
+	welcomeModalSeenAt?: Date | null;
+	activeModel: string;
+
+	// model name and system prompts
+	customPrompts?: Record<string, string>;
+
+	/**
+	 * Per‑model overrides to enable multimodal (image) support
+	 * even when not advertised by the provider/model list.
+	 * Only the `true` value is meaningful (enables images).
+	 */
+	multimodalOverrides?: Record<string, boolean>;
+
+	/**
+	 * Per‑model overrides to enable tool calling (OpenAI tools/function calling)
+	 * even when not advertised by the provider list. Only `true` is meaningful.
+	 */
+	toolsOverrides?: Record<string, boolean>;
+
+	/**
+	 * Per-model toggle to hide Omni prompt suggestions shown near the composer.
+	 * When set to `true`, prompt examples for that model are suppressed.
+	 */
+	hidePromptExamples?: Record<string, boolean>;
+
+	/**
+	 * Per-model inference provider preference.
+	 * Values: "auto" (default), "fastest", "cheapest", or a specific provider name (e.g., "together", "sambanova").
+	 * The value is appended to the model ID when making inference requests (e.g., "model:fastest").
+	 */
+	providerOverrides?: Record<string, string>;
+
+	/**
+	 * Preferred assistant output behavior in the chat UI.
+	 * - "raw": show provider-native stream chunks
+	 * - "smooth": show smoothed stream chunks
+	 */
+	streamingMode: StreamingMode;
+	directPaste: boolean;
+
+	/**
+	 * Whether haptic feedback is enabled on supported touch devices.
+	 * Uses the ios-haptics library for cross-platform vibration.
+	 */
+	hapticsEnabled: boolean;
+
+	/**
+	 * Autopilot mode — AI auto-continues after tool calls without user intervention.
+	 * When enabled, the model loops through tool calls automatically up to maxSteps.
+	 */
+	autopilotEnabled: boolean;
+
+	/**
+	 * Organization to bill inference requests to (HuggingChat only).
+	 * Stores the org's preferred_username. If empty/undefined, bills to personal account.
+	 */
+	billingOrganization?: string;
+}
+
+export type SettingsEditable = Omit<Settings, "welcomeModalSeenAt" | "createdAt" | "updatedAt">;
+// TODO: move this to a constant file along with other constants
+export const DEFAULT_SETTINGS = {
+	shareConversationsWithModelAuthors: true,
+	activeModel: defaultModel.id,
+	customPrompts: {},
+	multimodalOverrides: {},
+	toolsOverrides: {},
+	hidePromptExamples: {},
+	providerOverrides: {},
+	streamingMode: "smooth",
+	directPaste: false,
+	hapticsEnabled: true,
+	autopilotEnabled: true,
+} satisfies SettingsEditable;

package/src/ruvocal/src/lib/types/SharedConversation.ts

@@ -0,0 +1,9 @@
+import type { Conversation } from "./Conversation";
+
+export type SharedConversation = Pick<
+	Conversation,
+	"model" | "title" | "rootMessageId" | "messages" | "preprompt" | "createdAt" | "updatedAt"
+> & {
+	_id: string;
+	hash: string;
+};

package/src/ruvocal/src/lib/types/Template.ts

@@ -0,0 +1,6 @@
+import type { Message } from "./Message";
+
+export type ChatTemplateInput = {
+	messages: Pick<Message, "from" | "content" | "files">[];
+	preprompt?: string;
+};

package/src/ruvocal/src/lib/types/Timestamps.ts

@@ -0,0 +1,4 @@
+export interface Timestamps {
+	createdAt: Date;
+	updatedAt: Date;
+}

package/src/ruvocal/src/lib/types/TokenCache.ts

@@ -0,0 +1,6 @@
+import type { Timestamps } from "./Timestamps";
+
+export interface TokenCache extends Timestamps {
+	tokenHash: string; // sha256 of the bearer token
+	userId: string; // the matching hf user id
+}

package/src/ruvocal/src/lib/types/Tool.ts

@@ -0,0 +1,74 @@
+export enum ToolResultStatus {
+	Success = "success",
+	Error = "error",
+}
+
+export interface ToolCall {
+	name: string;
+	parameters: Record<string, string | number | boolean>;
+	toolId?: string;
+}
+
+export interface ToolResultSuccess {
+	status: ToolResultStatus.Success;
+	call: ToolCall;
+	outputs: Record<string, unknown>[];
+	display?: boolean;
+}
+
+export interface ToolResultError {
+	status: ToolResultStatus.Error;
+	call: ToolCall;
+	message: string;
+	display?: boolean;
+}
+
+export type ToolResult = ToolResultSuccess | ToolResultError;
+
+export interface ToolFront {
+	_id: string;
+	name: string;
+	displayName?: string;
+	description?: string;
+	color?: string;
+	icon?: string;
+	type?: "config" | "community";
+	isOnByDefault?: boolean;
+	isLocked?: boolean;
+	mimeTypes?: string[];
+	timeToUseMS?: number;
+}
+
+// MCP Server types
+export interface KeyValuePair {
+	key: string;
+	value: string;
+}
+
+export type ServerStatus = "connected" | "connecting" | "disconnected" | "error";
+
+export interface MCPTool {
+	name: string;
+	description?: string;
+	inputSchema?: unknown;
+}
+
+export interface MCPServer {
+	id: string;
+	name: string;
+	url: string;
+	type: "base" | "custom";
+	headers?: KeyValuePair[];
+	env?: KeyValuePair[];
+	status?: ServerStatus;
+	isLocked?: boolean;
+	tools?: MCPTool[];
+	errorMessage?: string;
+	// Indicates server reports or appears to require OAuth or other auth
+	authRequired?: boolean;
+}
+
+export interface MCPServerApi {
+	url: string;
+	headers?: KeyValuePair[];
+}

package/src/ruvocal/src/lib/types/UrlDependency.ts

@@ -0,0 +1,5 @@
+/* eslint-disable no-shadow */
+export enum UrlDependency {
+	ConversationList = "conversation:list",
+	Conversation = "conversation:id",
+}

package/src/ruvocal/src/lib/types/User.ts

@@ -0,0 +1,14 @@
+import type { ObjectId } from "mongodb";
+import type { Timestamps } from "./Timestamps";
+
+export interface User extends Timestamps {
+	_id: ObjectId;
+
+	username?: string;
+	name: string;
+	email?: string;
+	avatarUrl: string | undefined;
+	hfUserId: string;
+	isAdmin?: boolean;
+	isEarlyAccess?: boolean;
+}

package/src/ruvocal/src/lib/utils/PublicConfig.svelte.ts

@@ -0,0 +1,75 @@
+import type { env as publicEnv } from "$env/dynamic/public";
+import { page } from "$app/state";
+import { base } from "$app/paths";
+
+import type { Transporter } from "@sveltejs/kit";
+import { getContext } from "svelte";
+
+type PublicConfigKey = keyof typeof publicEnv;
+
+class PublicConfigManager {
+	#configStore = $state<Record<PublicConfigKey, string>>({});
+
+	constructor(initialConfig?: Record<PublicConfigKey, string>) {
+		this.init = this.init.bind(this);
+		this.getPublicConfig = this.getPublicConfig.bind(this);
+		if (initialConfig) {
+			this.init(initialConfig);
+		}
+	}
+
+	init(publicConfig: Record<PublicConfigKey, string>) {
+		this.#configStore = publicConfig;
+	}
+
+	get(key: PublicConfigKey) {
+		return this.#configStore[key];
+	}
+
+	getPublicConfig() {
+		return this.#configStore;
+	}
+
+	get isHuggingChat() {
+		return this.#configStore.PUBLIC_APP_ASSETS === "huggingchat";
+	}
+
+	get assetPath() {
+		// Use relative path when PUBLIC_ORIGIN is empty (avoids cross-origin issues
+		// when accessed via port-forwards or reverse proxies)
+		const origin = this.#configStore.PUBLIC_ORIGIN || "";
+		return origin + base + "/" + (this.#configStore.PUBLIC_APP_ASSETS || "chatui");
+	}
+}
+type ConfigProxy = PublicConfigManager & { [K in PublicConfigKey]: string };
+
+export function getConfigManager(initialConfig?: Record<PublicConfigKey, string>) {
+	const publicConfigManager = new PublicConfigManager(initialConfig);
+
+	const publicConfig: ConfigProxy = new Proxy(publicConfigManager, {
+		get(target, prop) {
+			if (prop in target) {
+				return Reflect.get(target, prop);
+			}
+			if (typeof prop === "string") {
+				return target.get(prop as PublicConfigKey);
+			}
+			return undefined;
+		},
+		set(target, prop, value, receiver) {
+			if (prop in target) {
+				return Reflect.set(target, prop, value, receiver);
+			}
+			return false;
+		},
+	}) as ConfigProxy;
+	return publicConfig;
+}
+
+export const publicConfigTransporter: Transporter = {
+	encode: (value) =>
+		value instanceof PublicConfigManager ? JSON.stringify(value.getPublicConfig()) : false,
+	decode: (value) => getConfigManager(JSON.parse(value)),
+};
+
+export const usePublicConfig = () => getContext<ConfigProxy>("publicConfig");

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

@@ -0,0 +1,17 @@
+import { goto } from "$app/navigation";
+import { base } from "$app/paths";
+import { page } from "$app/state";
+
+/**
+ * Redirects to the login page if the user is not authenticated
+ * and the login feature is enabled.
+ */
+export function requireAuthUser(): boolean {
+	if (page.data.loginEnabled && !page.data.user) {
+		const next = page.url.pathname + page.url.search;
+		const url = `${base}/login?next=${encodeURIComponent(next)}`;
+		goto(url, { invalidateAll: true });
+		return true;
+	}
+	return false;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Chunk array into arrays of length at most `chunkSize`
+ *
+ * @param chunkSize must be greater than or equal to 1
+ */
+export function chunk<T extends unknown[] | string>(arr: T, chunkSize: number): T[] {
+	if (isNaN(chunkSize) || chunkSize < 1) {
+		throw new RangeError("Invalid chunk size: " + chunkSize);
+	}
+
+	if (!arr.length) {
+		return [];
+	}
+
+	/// Small optimization to not chunk buffers unless needed
+	if (arr.length <= chunkSize) {
+		return [arr];
+	}
+
+	return range(Math.ceil(arr.length / chunkSize)).map((i) => {
+		return arr.slice(i * chunkSize, (i + 1) * chunkSize);
+	}) as T[];
+}
+
+function range(n: number, b?: number): number[] {
+	return b
+		? Array(b - n)
+				.fill(0)
+				.map((_, i) => n + i)
+		: Array(n)
+				.fill(0)
+				.map((_, i) => i);
+}

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

@@ -0,0 +1,13 @@
+import { browser } from "$app/environment";
+
+export function cookiesAreEnabled(): boolean {
+	if (!browser) return false;
+	if (navigator.cookieEnabled) return navigator.cookieEnabled;
+
+	// Create cookie
+	document.cookie = "cookietest=1";
+	const ret = document.cookie.indexOf("cookietest=") != -1;
+	// Delete cookie
+	document.cookie = "cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT";
+	return ret;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * A debounce function that works in both browser and Nodejs.
+ * For pure Nodejs work, prefer the `Debouncer` class.
+ */
+export function debounce<T extends unknown[]>(
+	callback: (...rest: T) => unknown,
+	limit: number
+): (...rest: T) => void {
+	let timer: ReturnType<typeof setTimeout>;
+
+	return function (...rest) {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			callback(...rest);
+		}, limit);
+	};
+}

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

@@ -0,0 +1,6 @@
+export function deepestChild(el: HTMLElement): HTMLElement {
+	if (el.lastElementChild && el.lastElementChild.nodeType !== Node.TEXT_NODE) {
+		return deepestChild(el.lastElementChild as HTMLElement);
+	}
+	return el;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Generates a Google favicon URL for the given server URL
+ * @param serverUrl - The MCP server URL (e.g., "https://mcp.exa.ai/mcp")
+ * @param size - The size of the favicon in pixels (default: 64)
+ * @returns The Google favicon service URL
+ */
+export function getMcpServerFaviconUrl(serverUrl: string, size: number = 64): string {
+	try {
+		const parsed = new URL(serverUrl);
+		// Extract root domain (e.g., "exa.ai" from "mcp.exa.ai")
+		// Google's favicon service needs the root domain, not subdomains
+		const hostnameParts = parsed.hostname.split(".");
+		const rootDomain =
+			hostnameParts.length >= 2 ? hostnameParts.slice(-2).join(".") : parsed.hostname;
+		const domain = `${parsed.protocol}//${rootDomain}`;
+		return `https://www.google.com/s2/favicons?sz=${size}&domain_url=${encodeURIComponent(domain)}`;
+	} catch {
+		// If URL parsing fails, just use the raw serverUrl - Google will handle it
+		return `https://www.google.com/s2/favicons?sz=${size}&domain_url=${encodeURIComponent(serverUrl)}`;
+	}
+}

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

@@ -0,0 +1,23 @@
+export async function fetchJSON<T>(
+	url: string,
+	options?: {
+		fetch?: typeof window.fetch;
+		allowNull?: boolean;
+	}
+): Promise<T> {
+	const response = await (options?.fetch ?? fetch)(url);
+	if (!response.ok) {
+		throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+	}
+
+	// Handle empty responses (which parse to null)
+	const text = await response.text();
+	if (!text || text.trim() === "") {
+		if (options?.allowNull) {
+			return null as T;
+		}
+		throw new Error(`Received empty response from ${url} but allowNull is not set to true`);
+	}
+
+	return JSON.parse(text);
+}

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

@@ -0,0 +1,14 @@
+const file2base64 = (file: File): Promise<string> => {
+	return new Promise<string>((resolve, reject) => {
+		const reader = new FileReader();
+		reader.readAsDataURL(file);
+		reader.onload = () => {
+			const dataUrl = reader.result as string;
+			const base64 = dataUrl.split(",")[1];
+			resolve(base64);
+		};
+		reader.onerror = (error) => reject(error);
+	});
+};
+
+export default file2base64;

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

@@ -0,0 +1,37 @@
+export function formatUserCount(userCount: number): string {
+	const userCountRanges: { min: number; max: number; label: string }[] = [
+		{ min: 0, max: 1, label: "1" },
+		{ min: 2, max: 9, label: "1-10" },
+		{ min: 10, max: 49, label: "10+" },
+		{ min: 50, max: 99, label: "50+" },
+		{ min: 100, max: 299, label: "100+" },
+		{ min: 300, max: 499, label: "300+" },
+		{ min: 500, max: 999, label: "500+" },
+		{ min: 1_000, max: 2_999, label: "1k+" },
+		{ min: 3_000, max: 4_999, label: "3k+" },
+		{ min: 5_000, max: 9_999, label: "5k+" },
+		{ min: 10_000, max: 19_999, label: "10k+" },
+		{ min: 20_000, max: 29_999, label: "20k+" },
+		{ min: 30_000, max: 39_999, label: "30k+" },
+		{ min: 40_000, max: 49_999, label: "40k+" },
+		{ min: 50_000, max: 59_999, label: "50k+" },
+		{ min: 60_000, max: 69_999, label: "60k+" },
+		{ min: 70_000, max: 79_999, label: "70k+" },
+		{ min: 80_000, max: 89_999, label: "80k+" },
+		{ min: 90_000, max: 99_999, label: "90k+" },
+		{ min: 100_000, max: 109_999, label: "100k+" },
+		{ min: 110_000, max: 119_999, label: "110k+" },
+		{ min: 120_000, max: 129_999, label: "120k+" },
+		{ min: 130_000, max: 139_999, label: "130k+" },
+		{ min: 140_000, max: 149_999, label: "140k+" },
+		{ min: 150_000, max: 199_999, label: "150k+" },
+		{ min: 200_000, max: 299_999, label: "200k+" },
+		{ min: 300_000, max: 499_999, label: "300k+" },
+		{ min: 500_000, max: 749_999, label: "500k+" },
+		{ min: 750_000, max: 999_999, label: "750k+" },
+		{ min: 1_000_000, max: Infinity, label: "1M+" },
+	];
+
+	const range = userCountRanges.find(({ min, max }) => userCount >= min && userCount <= max);
+	return range?.label ?? "";
+}

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

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "vitest";
+
+import type { Message } from "$lib/types/Message";
+import { MessageUpdateStatus, MessageUpdateType } from "$lib/types/MessageUpdate";
+import { isAssistantGenerationTerminal, isConversationGenerationActive } from "./generationState";
+
+function assistantMessage(overrides: Partial<Message> = {}): Message {
+	return {
+		from: "assistant",
+		id: "assistant-1" as Message["id"],
+		content: "",
+		children: [],
+		...overrides,
+	};
+}
+
+describe("generationState", () => {
+	test("returns active when assistant has no terminal update", () => {
+		const messages = [
+			assistantMessage({
+				updates: [{ type: MessageUpdateType.Stream, token: "Hello" }],
+			}),
+		];
+
+		expect(isConversationGenerationActive(messages)).toBe(true);
+	});
+
+	test("treats final answer update as terminal", () => {
+		const message = assistantMessage({
+			updates: [{ type: MessageUpdateType.FinalAnswer, text: "Done", interrupted: false }],
+		});
+
+		expect(isAssistantGenerationTerminal(message)).toBe(true);
+		expect(isConversationGenerationActive([message])).toBe(false);
+	});
+
+	test("treats error status update as terminal", () => {
+		const message = assistantMessage({
+			updates: [
+				{
+					type: MessageUpdateType.Status,
+					status: MessageUpdateStatus.Error,
+					message: "Something went wrong",
+				},
+			],
+		});
+
+		expect(isAssistantGenerationTerminal(message)).toBe(true);
+		expect(isConversationGenerationActive([message])).toBe(false);
+	});
+
+	test("treats finished status update as terminal", () => {
+		const message = assistantMessage({
+			updates: [
+				{
+					type: MessageUpdateType.Status,
+					status: MessageUpdateStatus.Finished,
+				},
+			],
+		});
+
+		expect(isAssistantGenerationTerminal(message)).toBe(true);
+		expect(isConversationGenerationActive([message])).toBe(false);
+	});
+
+	test("treats interrupted assistant message as terminal", () => {
+		const message = assistantMessage({
+			interrupted: true,
+			updates: [{ type: MessageUpdateType.Stream, token: "partial" }],
+		});
+
+		expect(isAssistantGenerationTerminal(message)).toBe(true);
+		expect(isConversationGenerationActive([message])).toBe(false);
+	});
+});

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

@@ -0,0 +1,26 @@
+import type { Message } from "$lib/types/Message";
+import { MessageUpdateStatus, MessageUpdateType } from "$lib/types/MessageUpdate";
+
+export function isAssistantGenerationTerminal(message?: Message): boolean {
+	if (!message || message.from !== "assistant") return true;
+
+	if (message.interrupted === true) return true;
+
+	const updates = message.updates ?? [];
+	const hasFinalAnswer = updates.some((update) => update.type === MessageUpdateType.FinalAnswer);
+	if (hasFinalAnswer) return true;
+
+	return updates.some(
+		(update) =>
+			update.type === MessageUpdateType.Status &&
+			(update.status === MessageUpdateStatus.Error ||
+				update.status === MessageUpdateStatus.Finished)
+	);
+}
+
+export function isConversationGenerationActive(messages: Message[]): boolean {
+	const lastAssistant = [...messages].reverse().find((message) => message.from === "assistant");
+	if (!lastAssistant) return false;
+
+	return !isAssistantGenerationTerminal(lastAssistant);
+}

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

@@ -0,0 +1,41 @@
+export function getHref(
+	url: URL | string,
+	modifications: {
+		newKeys?: Record<string, string | undefined | null>;
+		existingKeys?: { behaviour: "delete_except" | "delete"; keys: string[] };
+	}
+) {
+	const newUrl = new URL(url);
+	const { newKeys, existingKeys } = modifications;
+
+	// exsiting keys logic
+	if (existingKeys) {
+		const { behaviour, keys } = existingKeys;
+		if (behaviour === "delete") {
+			for (const key of keys) {
+				newUrl.searchParams.delete(key);
+			}
+		} else {
+			// delete_except
+			const keysToPreserve = keys;
+			for (const key of [...newUrl.searchParams.keys()]) {
+				if (!keysToPreserve.includes(key)) {
+					newUrl.searchParams.delete(key);
+				}
+			}
+		}
+	}
+
+	// new keys logic
+	if (newKeys) {
+		for (const [key, val] of Object.entries(newKeys)) {
+			if (val) {
+				newUrl.searchParams.set(key, val);
+			} else {
+				newUrl.searchParams.delete(key);
+			}
+		}
+	}
+
+	return newUrl.toString();
+}

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

@@ -0,0 +1,7 @@
+export async function getReturnFromGenerator<T, R>(generator: AsyncGenerator<T, R>): Promise<R> {
+	let result: IteratorResult<T, R>;
+	do {
+		result = await generator.next();
+	} while (!result.done); // Keep calling `next()` until `done` is true
+	return result.value; // Return the final value
+}