@aigentic/ruflo 3.7.0-alpha.69

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

@@ -0,0 +1,77 @@
+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" | "wasm";
+	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;
+	// For WASM servers: active template info
+	wasmTemplateId?: string;
+	wasmTemplateName?: string;
+}
+
+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
+}

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

@@ -0,0 +1,64 @@
+import { browser } from "$app/environment";
+import type { WebHaptics } from "web-haptics";
+
+let instance: WebHaptics | null = null;
+let enabled = true;
+
+/**
+ * Lazily initializes the WebHaptics instance on first use.
+ * Avoids importing at module level so SSR doesn't break.
+ */
+async function getInstance(): Promise<WebHaptics | null> {
+	if (!browser || !supportsHaptics()) return null;
+	if (instance) return instance;
+
+	try {
+		const { WebHaptics: WH } = await import("web-haptics");
+		instance = new WH();
+		return instance;
+	} catch {
+		return null;
+	}
+}
+
+/** Call from the settings store to keep haptics in sync with user preference. */
+export function setHapticsEnabled(value: boolean) {
+	enabled = value;
+}
+
+/** Whether the device likely supports haptic feedback (touch screen present). */
+export function supportsHaptics(): boolean {
+	return browser && navigator.maxTouchPoints > 0;
+}
+
+// ── Internals ────────────────────────────────────────────────────────
+
+/** Fire a haptic pattern, swallowing errors so callers can safely fire-and-forget. */
+function fire(pattern: string): void {
+	if (!enabled) return;
+	Promise.resolve(getInstance())
+		.then((h) => h?.trigger(pattern))
+		.catch(() => {});
+}
+
+// ── Semantic haptic actions ──────────────────────────────────────────
+
+/** Light tap — for routine actions (send message, toggle, navigate). */
+export function tap() {
+	fire("light");
+}
+
+/** Success confirmation — double-tap pattern (copy, share, save). */
+export function confirm() {
+	fire("success");
+}
+
+/** Error / destructive warning — three rapid taps (delete, stop generation). */
+export function error() {
+	fire("error");
+}
+
+/** Selection change — subtle tap for pickers and selections. */
+export function selection() {
+	fire("selection");
+}

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

@@ -0,0 +1,12 @@
+import type { Conversation } from "$lib/types/Conversation";
+import { sha256 } from "./sha256";
+
+export async function hashConv(conv: Conversation) {
+	// messages contains the conversation message but only the immutable part
+	const messages = conv.messages.map((message) => {
+		return (({ from, id, content }) => ({ from, id, content }))(message);
+	});
+
+	const hash = await sha256(JSON.stringify(messages));
+	return hash;
+}

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

@@ -0,0 +1,17 @@
+// Client-safe HF utilities used in UI components
+
+export function isStrictHfMcpLogin(urlString: string): boolean {
+	try {
+		const u = new URL(urlString);
+		const host = u.hostname.toLowerCase();
+		const allowedHosts = new Set(["hf.co", "huggingface.co"]);
+		return (
+			u.protocol === "https:" &&
+			allowedHosts.has(host) &&
+			u.pathname === "/mcp" &&
+			u.search === "?login"
+		);
+	} catch {
+		return false;
+	}
+}

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

@@ -0,0 +1,7 @@
+// Approximate width from which we disable autofocus
+const TABLET_VIEWPORT_WIDTH = 768;
+
+export function isDesktop(window: Window) {
+	const { innerWidth } = window;
+	return innerWidth > TABLET_VIEWPORT_WIDTH;
+}

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

@@ -0,0 +1,8 @@
+export function isURL(url: string) {
+	try {
+		new URL(url);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}

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

@@ -0,0 +1,16 @@
+import { browser } from "$app/environment";
+
+export function isVirtualKeyboard(): boolean {
+	if (!browser) return false;
+
+	// Check for touch capability
+	if (navigator.maxTouchPoints > 0 && screen.width <= 768) return true;
+
+	// Check for touch events
+	if ("ontouchstart" in window) return true;
+
+	// Fallback to user agent string check
+	const userAgent = navigator.userAgent.toLowerCase();
+
+	return /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
+}