ruflo 3.5.1 → 3.5.3

package/src/ruvocal/src/lib/stores/settings.ts

@@ -0,0 +1,182 @@
+import { browser } from "$app/environment";
+import { invalidate } from "$app/navigation";
+import { base } from "$app/paths";
+import type { StreamingMode } from "$lib/types/Settings";
+import { UrlDependency } from "$lib/types/UrlDependency";
+import { getContext, setContext } from "svelte";
+import { type Writable, writable, get } from "svelte/store";
+
+type SettingsStore = {
+	shareConversationsWithModelAuthors: boolean;
+	welcomeModalSeen: boolean;
+	welcomeModalSeenAt: Date | null;
+	activeModel: string;
+	customPrompts: Record<string, string>;
+	multimodalOverrides: Record<string, boolean>;
+	toolsOverrides: Record<string, boolean>;
+	hidePromptExamples: Record<string, boolean>;
+	providerOverrides: Record<string, string>;
+	recentlySaved: boolean;
+	streamingMode: StreamingMode;
+	directPaste: boolean;
+	hapticsEnabled: boolean;
+	autopilotEnabled: boolean;
+	billingOrganization?: string;
+};
+
+type SettingsStoreWritable = Writable<SettingsStore> & {
+	instantSet: (settings: Partial<SettingsStore>) => Promise<void>;
+	initValue: <K extends keyof SettingsStore>(
+		key: K,
+		nestedKey: string,
+		value: string | boolean
+	) => Promise<void>;
+};
+
+export function useSettingsStore() {
+	return getContext<SettingsStoreWritable>("settings");
+}
+
+export function createSettingsStore(
+	initialValue: Omit<SettingsStore, "recentlySaved" | "autopilotEnabled"> &
+		Partial<Pick<SettingsStore, "autopilotEnabled">>
+) {
+	const baseStore = writable({
+		autopilotEnabled: true,
+		...initialValue,
+		recentlySaved: false,
+	});
+
+	let timeoutId: NodeJS.Timeout;
+	let showSavedOnNextSync = false;
+
+	async function setSettings(settings: Partial<SettingsStore>) {
+		baseStore.update((s) => ({
+			...s,
+			...settings,
+		}));
+
+		if (browser) {
+			showSavedOnNextSync = true; // User edit, should show "Saved"
+			clearTimeout(timeoutId);
+			timeoutId = setTimeout(async () => {
+				await fetch(`${base}/settings`, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify(get(baseStore)),
+				});
+
+				invalidate(UrlDependency.ConversationList);
+
+				if (showSavedOnNextSync) {
+					// set savedRecently to true for 3s
+					baseStore.update((s) => ({
+						...s,
+						recentlySaved: true,
+					}));
+					setTimeout(() => {
+						baseStore.update((s) => ({
+							...s,
+							recentlySaved: false,
+						}));
+					}, 3000);
+				}
+
+				showSavedOnNextSync = false;
+			}, 300);
+			// debounce server calls by 300ms
+		}
+	}
+
+	async function initValue<K extends keyof SettingsStore>(
+		key: K,
+		nestedKey: string,
+		value: string | boolean
+	) {
+		const currentStore = get(baseStore);
+		const currentNestedObject = currentStore[key] as Record<string, string | boolean>;
+
+		// Only initialize if undefined
+		if (currentNestedObject?.[nestedKey] !== undefined) {
+			return;
+		}
+
+		// Update the store
+		const newNestedObject = {
+			...(currentNestedObject || {}),
+			[nestedKey]: value,
+		};
+
+		baseStore.update((s) => ({
+			...s,
+			[key]: newNestedObject,
+		}));
+
+		// Save to server (debounced) - note: we don't set showSavedOnNextSync
+		if (browser) {
+			clearTimeout(timeoutId);
+			timeoutId = setTimeout(async () => {
+				await fetch(`${base}/settings`, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify(get(baseStore)),
+				});
+
+				invalidate(UrlDependency.ConversationList);
+
+				if (showSavedOnNextSync) {
+					baseStore.update((s) => ({
+						...s,
+						recentlySaved: true,
+					}));
+					setTimeout(() => {
+						baseStore.update((s) => ({
+							...s,
+							recentlySaved: false,
+						}));
+					}, 3000);
+				}
+
+				showSavedOnNextSync = false;
+			}, 300);
+		}
+	}
+	async function instantSet(settings: Partial<SettingsStore>) {
+		baseStore.update((s) => ({
+			...s,
+			...settings,
+		}));
+
+		if (browser) {
+			await fetch(`${base}/settings`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					...get(baseStore),
+					...settings,
+				}),
+			});
+			invalidate(UrlDependency.ConversationList);
+		}
+	}
+
+	const newStore = {
+		subscribe: baseStore.subscribe,
+		set: setSettings,
+		instantSet,
+		initValue,
+		update: (fn: (s: SettingsStore) => SettingsStore) => {
+			setSettings(fn(get(baseStore)));
+		},
+	} satisfies SettingsStoreWritable;
+
+	setContext("settings", newStore);
+
+	return newStore;
+}

package/src/ruvocal/src/lib/stores/shareModal.ts

@@ -0,0 +1,13 @@
+import { writable } from "svelte/store";
+
+function createShareModalStore() {
+	const { subscribe, set } = writable(false);
+
+	return {
+		subscribe,
+		open: () => set(true),
+		close: () => set(false),
+	};
+}
+
+export const shareModal = createShareModalStore();

package/src/ruvocal/src/lib/stores/titleUpdate.ts

@@ -0,0 +1,8 @@
+import { writable } from "svelte/store";
+
+export interface TitleUpdate {
+	convId: string;
+	title: string;
+}
+
+export default writable<TitleUpdate | null>(null);

package/src/ruvocal/src/lib/switchTheme.ts

@@ -0,0 +1,124 @@
+export type ThemePreference = "light" | "dark" | "system";
+
+type ThemeState = {
+	preference: ThemePreference;
+	isDark: boolean;
+};
+
+type ThemeSubscriber = (state: ThemeState) => void;
+
+let currentPreference: ThemePreference = "system";
+const subscribers = new Set<ThemeSubscriber>();
+
+function notify(preference: ThemePreference, isDark: boolean) {
+	for (const subscriber of subscribers) {
+		subscriber({ preference, isDark });
+	}
+}
+
+export function subscribeToTheme(subscriber: ThemeSubscriber) {
+	subscribers.add(subscriber);
+
+	if (typeof document !== "undefined") {
+		const preference = getThemePreference();
+		const isDark = document.documentElement.classList.contains("dark");
+		subscriber({ preference, isDark });
+	} else {
+		subscriber({ preference: "system", isDark: false });
+	}
+
+	return () => {
+		subscribers.delete(subscriber);
+	};
+}
+
+function setMetaThemeColor(isDark: boolean) {
+	const metaTheme = document.querySelector('meta[name="theme-color"]') as HTMLMetaElement | null;
+	if (!metaTheme) return;
+	metaTheme.setAttribute("content", isDark ? "rgb(26, 36, 50)" : "rgb(249, 250, 251)");
+}
+
+function applyDarkClass(isDark: boolean) {
+	const { classList } = document.querySelector("html") as HTMLElement;
+	if (isDark) classList.add("dark");
+	else classList.remove("dark");
+	setMetaThemeColor(isDark);
+	notify(currentPreference, isDark);
+}
+
+export function getThemePreference(): ThemePreference {
+	const raw = typeof localStorage !== "undefined" ? localStorage.getItem("theme") : null;
+	if (raw === "light" || raw === "dark" || raw === "system") {
+		currentPreference = raw;
+		return raw;
+	}
+	currentPreference = "system";
+	return "system";
+}
+
+/**
+ * Explicitly set the theme preference and apply it immediately.
+ * - "light": force light
+ * - "dark": force dark
+ * - "system": follow the OS preference
+ */
+export function setTheme(preference: ThemePreference) {
+	try {
+		localStorage.theme = preference;
+	} catch (_err) {
+		void 0; // ignore write errors
+	}
+
+	const mql = window.matchMedia("(prefers-color-scheme: dark)");
+	currentPreference = preference;
+	const resolve = () =>
+		applyDarkClass(preference === "dark" || (preference === "system" && mql.matches));
+
+	// Apply now
+	resolve();
+
+	// If following system, listen for changes; otherwise remove listener
+	const listener = () => resolve();
+	// Store on window to allow replacing listener later
+	const key = "__theme_mql_listener" as const;
+	const w = window as unknown as {
+		[key: string]: ((this: MediaQueryList, ev: MediaQueryListEvent) => void) | undefined;
+	};
+	const existing = w[key];
+	if (existing) {
+		try {
+			mql.removeEventListener("change", existing);
+		} catch (_err) {
+			// older Safari compatibility
+			const legacy = (
+				mql as unknown as {
+					removeListener?: (l: (this: MediaQueryList, ev: MediaQueryListEvent) => void) => void;
+				}
+			).removeListener;
+			legacy?.(existing);
+		}
+		w[key] = undefined;
+	}
+	if (preference === "system") {
+		try {
+			mql.addEventListener("change", listener);
+		} catch (_err) {
+			// older Safari compatibility
+			const legacy = (
+				mql as unknown as {
+					addListener?: (l: (this: MediaQueryList, ev: MediaQueryListEvent) => void) => void;
+				}
+			).addListener;
+			legacy?.(listener);
+		}
+		w[key] = listener;
+	}
+}
+
+// Backward-compatible toggle used by the sidebar button
+export function switchTheme() {
+	const html = document.querySelector("html") as HTMLElement;
+	const isDark = html.classList.contains("dark");
+	const next: ThemePreference = isDark ? "light" : "dark";
+	setTheme(next);
+}

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

@@ -0,0 +1,8 @@
+// Ideally shouldn't be needed, see https://github.com/huggingface/chat-ui/pull/88#issuecomment-1523173850
+
+import type { Conversation } from "./Conversation";
+import type { Timestamps } from "./Timestamps";
+
+export interface AbortedGeneration extends Timestamps {
+	conversationId: Conversation["_id"];
+}

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

@@ -0,0 +1,31 @@
+import type { ObjectId } from "mongodb";
+import type { User } from "./User";
+import type { Timestamps } from "./Timestamps";
+import type { ReviewStatus } from "./Review";
+
+export interface Assistant extends Timestamps {
+	_id: ObjectId;
+	createdById: User["_id"] | string; // user id or session
+	createdByName?: User["username"];
+	avatar?: string;
+	name: string;
+	description?: string;
+	modelId: string;
+	exampleInputs: string[];
+	preprompt: string;
+	userCount?: number;
+	review: ReviewStatus;
+	// Web search / RAG removed in this build
+	generateSettings?: {
+		temperature?: number;
+		top_p?: number;
+		frequency_penalty?: number;
+		top_k?: number;
+	};
+	dynamicPrompt?: boolean;
+	searchTokens: string[];
+	last24HoursCount: number;
+}
+
+// eslint-disable-next-line no-shadow
+// Removed duplicate unused SortKey enum (shared enum exists elsewhere)

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

@@ -0,0 +1,11 @@
+import type { Timestamps } from "./Timestamps";
+import type { Assistant } from "./Assistant";
+
+export interface AssistantStats extends Timestamps {
+	assistantId: Assistant["_id"];
+	date: {
+		at: Date;
+		span: "hour";
+	};
+	count: number;
+}

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

@@ -0,0 +1,4 @@
+export interface ConfigKey {
+	key: string; // unique
+	value: string;
+}

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

@@ -0,0 +1,9 @@
+import type { ObjectId } from "bson";
+
+export interface ConvSidebar {
+	id: ObjectId | string;
+	title: string;
+	updatedAt: Date;
+	model?: string;
+	avatarUrl?: string | Promise<string | undefined>;
+}

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

@@ -0,0 +1,27 @@
+import type { ObjectId } from "mongodb";
+import type { Message } from "./Message";
+import type { Timestamps } from "./Timestamps";
+import type { User } from "./User";
+import type { Assistant } from "./Assistant";
+
+export interface Conversation extends Timestamps {
+	_id: ObjectId;
+
+	sessionId?: string;
+	userId?: User["_id"];
+
+	model: string;
+
+	title: string;
+	rootMessageId?: Message["id"];
+	messages: Message[];
+
+	meta?: {
+		fromShareId?: string;
+	};
+
+	preprompt?: string;
+	assistantId?: Assistant["_id"];
+
+	userAgent?: string;
+}

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

@@ -0,0 +1,13 @@
+import type { Timestamps } from "./Timestamps";
+
+export interface ConversationStats extends Timestamps {
+	date: {
+		at: Date;
+		span: "day" | "week" | "month";
+		field: "updatedAt" | "createdAt";
+	};
+	type: "conversation" | "message";
+	/**  _id => number of conversations/messages in the month */
+	distinct: "sessionId" | "userId" | "userOrSessionId" | "_id";
+	count: number;
+}

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

@@ -0,0 +1,41 @@
+import type { InferenceProvider } from "@huggingface/inference";
+import type { MessageUpdate } from "./MessageUpdate";
+import type { Timestamps } from "./Timestamps";
+import type { v4 } from "uuid";
+
+export type Message = Partial<Timestamps> & {
+	from: "user" | "assistant" | "system";
+	id: ReturnType<typeof v4>;
+	content: string;
+	updates?: MessageUpdate[];
+
+	// Optional server or client-side reasoning content (<think> blocks)
+	reasoning?: string;
+	score?: -1 | 0 | 1;
+	/**
+	 * Either contains the base64 encoded image data
+	 * or the hash of the file stored on the server
+	 **/
+	files?: MessageFile[];
+	interrupted?: boolean;
+
+	// Router metadata when using llm-router
+	routerMetadata?: {
+		route: string;
+		model: string;
+		provider?: InferenceProvider;
+	};
+
+	// needed for conversation trees
+	ancestors?: Message["id"][];
+
+	// goes one level deep
+	children?: Message["id"][];
+};
+
+export type MessageFile = {
+	type: "hash" | "base64";
+	name: string;
+	value: string;
+	mime: string;
+};

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

@@ -0,0 +1,10 @@
+import type { Session } from "./Session";
+import type { Timestamps } from "./Timestamps";
+import type { User } from "./User";
+
+export interface MessageEvent extends Pick<Timestamps, "createdAt"> {
+	userId: User["_id"] | Session["sessionId"];
+	ip?: string;
+	expiresAt: Date;
+	type: "message" | "export";
+}

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

@@ -0,0 +1,139 @@
+import type { InferenceProvider } from "@huggingface/inference";
+import type { ToolCall, ToolResult } from "$lib/types/Tool";
+
+export type MessageUpdate =
+	| MessageStatusUpdate
+	| MessageTitleUpdate
+	| MessageToolUpdate
+	| MessageStreamUpdate
+	| MessageFileUpdate
+	| MessageFinalAnswerUpdate
+	| MessageReasoningUpdate
+	| MessageRouterMetadataUpdate
+	| MessageAutopilotStepUpdate;
+
+export enum MessageUpdateType {
+	Status = "status",
+	Title = "title",
+	Tool = "tool",
+	Stream = "stream",
+	File = "file",
+	FinalAnswer = "finalAnswer",
+	Reasoning = "reasoning",
+	RouterMetadata = "routerMetadata",
+	AutopilotStep = "autopilotStep",
+}
+
+// Status
+export enum MessageUpdateStatus {
+	Started = "started",
+	Error = "error",
+	Finished = "finished",
+	KeepAlive = "keepAlive",
+}
+export interface MessageStatusUpdate {
+	type: MessageUpdateType.Status;
+	status: MessageUpdateStatus;
+	message?: string;
+	statusCode?: number;
+}
+
+// Everything else
+export interface MessageTitleUpdate {
+	type: MessageUpdateType.Title;
+	title: string;
+}
+export interface MessageStreamUpdate {
+	type: MessageUpdateType.Stream;
+	token: string;
+	/** Length of the original token. Used for compressed/persisted stream markers where token is empty. */
+	len?: number;
+}
+
+// Tool updates (for MCP and function calling)
+export enum MessageToolUpdateType {
+	Call = "call",
+	Result = "result",
+	Error = "error",
+	ETA = "eta",
+	Progress = "progress",
+}
+
+interface MessageToolUpdateBase<TSubtype extends MessageToolUpdateType> {
+	type: MessageUpdateType.Tool;
+	subtype: TSubtype;
+	uuid: string;
+}
+
+export interface MessageToolCallUpdate extends MessageToolUpdateBase<MessageToolUpdateType.Call> {
+	call: ToolCall;
+}
+
+export interface MessageToolResultUpdate
+	extends MessageToolUpdateBase<MessageToolUpdateType.Result> {
+	result: ToolResult;
+}
+
+export interface MessageToolErrorUpdate extends MessageToolUpdateBase<MessageToolUpdateType.Error> {
+	message: string;
+}
+
+export interface MessageToolEtaUpdate extends MessageToolUpdateBase<MessageToolUpdateType.ETA> {
+	eta: number;
+}
+
+export interface MessageToolProgressUpdate
+	extends MessageToolUpdateBase<MessageToolUpdateType.Progress> {
+	progress: number;
+	total?: number;
+	message?: string;
+}
+
+export type MessageToolUpdate =
+	| MessageToolCallUpdate
+	| MessageToolResultUpdate
+	| MessageToolErrorUpdate
+	| MessageToolEtaUpdate
+	| MessageToolProgressUpdate;
+
+export enum MessageReasoningUpdateType {
+	Stream = "stream",
+	Status = "status",
+}
+
+export type MessageReasoningUpdate = MessageReasoningStreamUpdate | MessageReasoningStatusUpdate;
+
+export interface MessageReasoningStreamUpdate {
+	type: MessageUpdateType.Reasoning;
+	subtype: MessageReasoningUpdateType.Stream;
+	token: string;
+}
+export interface MessageReasoningStatusUpdate {
+	type: MessageUpdateType.Reasoning;
+	subtype: MessageReasoningUpdateType.Status;
+	status: string;
+}
+
+export interface MessageFileUpdate {
+	type: MessageUpdateType.File;
+	name: string;
+	sha: string;
+	mime: string;
+}
+export interface MessageFinalAnswerUpdate {
+	type: MessageUpdateType.FinalAnswer;
+	text: string;
+	interrupted: boolean;
+}
+export interface MessageRouterMetadataUpdate {
+	type: MessageUpdateType.RouterMetadata;
+	route: string;
+	model: string;
+	provider?: InferenceProvider;
+}
+export interface MessageAutopilotStepUpdate {
+	type: MessageUpdateType.AutopilotStep;
+	step: number;
+	maxSteps: number;
+	toolCount: number;
+}

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

@@ -0,0 +1,7 @@
+import type { ObjectId } from "mongodb";
+
+export interface MigrationResult {
+	_id: ObjectId;
+	name: string;
+	status: "success" | "failure" | "ongoing";
+}

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

@@ -0,0 +1,23 @@
+import type { BackendModel } from "$lib/server/models";
+
+export type Model = Pick<
+	BackendModel,
+	| "id"
+	| "name"
+	| "displayName"
+	| "isRouter"
+	| "websiteUrl"
+	| "datasetName"
+	| "promptExamples"
+	| "parameters"
+	| "description"
+	| "logoUrl"
+	| "modelUrl"
+	| "datasetUrl"
+	| "preprompt"
+	| "multimodal"
+	| "multimodalAcceptedMimetypes"
+	| "unlisted"
+	| "hasInferenceAPI"
+	| "providers"
+>;

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

@@ -0,0 +1,12 @@
+import type { ObjectId } from "mongodb";
+import type { User } from "./User";
+import type { Assistant } from "./Assistant";
+import type { Timestamps } from "./Timestamps";
+
+export interface Report extends Timestamps {
+	_id: ObjectId;
+	createdBy: User["_id"] | string;
+	object: "assistant" | "tool";
+	contentId: Assistant["_id"];
+	reason?: string;
+}

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

@@ -0,0 +1,6 @@
+export enum ReviewStatus {
+	PRIVATE = "PRIVATE",
+	PENDING = "PENDING",
+	APPROVED = "APPROVED",
+	DENIED = "DENIED",
+}