ruflo 3.5.2 → 3.5.3

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

@@ -0,0 +1,262 @@
+import { describe, expect, it } from "vitest";
+import {
+	MessageUpdateStatus,
+	MessageUpdateType,
+	type MessageUpdate,
+} from "$lib/types/MessageUpdate";
+import { applyStreamingMode, resolveStreamingMode, smoothStreamUpdates } from "./messageUpdates";
+
+async function* fromArray<T>(values: T[]): AsyncGenerator<T> {
+	for (const value of values) {
+		yield value;
+	}
+}
+
+async function collect(iter: AsyncGenerator<MessageUpdate>) {
+	const updates: MessageUpdate[] = [];
+	for await (const update of iter) {
+		updates.push(update);
+	}
+	return updates;
+}
+
+const streamText = (updates: MessageUpdate[]) =>
+	updates
+		.filter((u) => u.type === MessageUpdateType.Stream)
+		.map((u) => u.token)
+		.join("");
+
+describe("smoothStreamUpdates", () => {
+	it("merges partial words and preserves final text", async () => {
+		const source: MessageUpdate[] = [
+			{ type: MessageUpdateType.Stream, token: "Hel" },
+			{ type: MessageUpdateType.Stream, token: "lo " },
+			{ type: MessageUpdateType.Stream, token: "wor" },
+			{ type: MessageUpdateType.Stream, token: "ld!" },
+			{ type: MessageUpdateType.Status, status: MessageUpdateStatus.Finished },
+		];
+
+		const updates = await collect(
+			smoothStreamUpdates(fromArray(source), {
+				minDelayMs: 0,
+				maxDelayMs: 0,
+				_internal: { detectChunk: (buffer) => /\S+\s+/.exec(buffer)?.[0] ?? null },
+			})
+		);
+
+		const streamedChunks = updates.filter((u) => u.type === MessageUpdateType.Stream);
+		expect(streamedChunks.map((u) => u.token)).toEqual(["Hello ", "world!"]);
+		expect(streamText(updates)).toBe("Hello world!");
+	});
+
+	it("flushes buffered stream text before non-stream updates", async () => {
+		const source: MessageUpdate[] = [
+			{ type: MessageUpdateType.Stream, token: "hello" },
+			{ type: MessageUpdateType.Stream, token: " world" },
+			{ type: MessageUpdateType.Title, title: "done" },
+		];
+
+		const updates = await collect(
+			smoothStreamUpdates(fromArray(source), { minDelayMs: 0, maxDelayMs: 0 })
+		);
+		expect(updates[0]).toMatchObject({ type: MessageUpdateType.Stream });
+		expect(updates[1]).toMatchObject({ type: MessageUpdateType.Stream });
+		expect(updates[2]).toEqual({ type: MessageUpdateType.Title, title: "done" });
+		expect(streamText(updates)).toBe("hello world");
+	});
+
+	it("spreads burst tokens over time", async () => {
+		const bigToken = "word ".repeat(40); // 200 chars, 40 words
+		const source: MessageUpdate[] = [{ type: MessageUpdateType.Stream, token: bigToken }];
+		let nowMs = 0;
+		const emitTimes: number[] = [];
+
+		const iter = smoothStreamUpdates(fromArray(source), {
+			minDelayMs: 5,
+			maxDelayMs: 80,
+			minRateCharsPerMs: 0.3,
+			_internal: {
+				now: () => nowMs,
+				sleep: async (ms: number) => {
+					nowMs += ms;
+				},
+				detectChunk: (buffer) => /\S+\s+/.exec(buffer)?.[0] ?? null,
+			},
+		});
+
+		for await (const update of iter) {
+			if (update.type === MessageUpdateType.Stream) {
+				emitTimes.push(nowMs);
+			}
+		}
+
+		// Should have multiple emissions
+		expect(emitTimes.length).toBeGreaterThan(5);
+		// Gap between first and last emission should be significant (not instant dump)
+		const totalSpread = (emitTimes.at(-1) ?? 0) - (emitTimes[0] ?? 0);
+		expect(totalSpread).toBeGreaterThan(100);
+	});
+
+	it("keeps delays within configured bounds", async () => {
+		const source: MessageUpdate[] = [
+			{
+				type: MessageUpdateType.Stream,
+				token: "one two three four five six seven eight nine ten ",
+			},
+		];
+		const delays: number[] = [];
+		let nowMs = 0;
+
+		await collect(
+			smoothStreamUpdates(fromArray(source), {
+				minDelayMs: 5,
+				maxDelayMs: 80,
+				minRateCharsPerMs: 0.3,
+				_internal: {
+					now: () => nowMs,
+					sleep: async (ms: number) => {
+						delays.push(ms);
+						nowMs += ms;
+					},
+					detectChunk: (buffer) => /\S+\s+/.exec(buffer)?.[0] ?? null,
+				},
+			})
+		);
+
+		expect(delays.length).toBeGreaterThan(2);
+		expect(delays.every((d) => d >= 5 && d <= 80)).toBe(true);
+		// First delay should be >= later delays (rate floor dominates initially)
+		expect(delays[0]).toBeGreaterThanOrEqual(delays.at(-1) ?? 0);
+	});
+
+	it("handles CJK text correctly", async () => {
+		const source: MessageUpdate[] = [{ type: MessageUpdateType.Stream, token: "你好，世界！" }];
+
+		const updates = await collect(
+			smoothStreamUpdates(fromArray(source), { minDelayMs: 0, maxDelayMs: 0 })
+		);
+
+		expect(streamText(updates)).toBe("你好，世界！");
+	});
+
+	it("propagates source errors to consumer", async () => {
+		async function* failingSource(): AsyncGenerator<MessageUpdate> {
+			yield { type: MessageUpdateType.Stream, token: "hello " };
+			throw new Error("source failed");
+		}
+
+		await expect(
+			collect(smoothStreamUpdates(failingSource(), { minDelayMs: 0, maxDelayMs: 0 }))
+		).rejects.toThrow("source failed");
+	});
+
+	it("propagates source errors even when no full chunk was emitted yet", async () => {
+		async function* failingSource(): AsyncGenerator<MessageUpdate> {
+			yield { type: MessageUpdateType.Stream, token: "hel" };
+			throw new Error("source failed");
+		}
+
+		await expect(
+			collect(
+				smoothStreamUpdates(failingSource(), {
+					minDelayMs: 0,
+					maxDelayMs: 0,
+					_internal: { detectChunk: (buffer) => /\S+\s+/.exec(buffer)?.[0] ?? null },
+				})
+			)
+		).rejects.toThrow("source failed");
+	});
+
+	it("drains queued stream chunks before throwing source errors", async () => {
+		async function* failingSource(): AsyncGenerator<MessageUpdate> {
+			yield { type: MessageUpdateType.Stream, token: "a " };
+			yield { type: MessageUpdateType.Stream, token: "b " };
+			yield { type: MessageUpdateType.Stream, token: "c " };
+			throw new Error("source failed");
+		}
+
+		const seen: MessageUpdate[] = [];
+		let seenError: Error | null = null;
+		try {
+			for await (const update of smoothStreamUpdates(failingSource(), {
+				minDelayMs: 0,
+				maxDelayMs: 0,
+				_internal: { detectChunk: (buffer) => /\S+\s+/.exec(buffer)?.[0] ?? null },
+			})) {
+				seen.push(update);
+			}
+		} catch (error) {
+			seenError = error as Error;
+		}
+
+		expect(streamText(seen)).toBe("a b c ");
+		expect(seenError?.message).toBe("source failed");
+	});
+
+	it("caps burst tail latency with backlog acceleration", async () => {
+		const source: MessageUpdate[] = [
+			{ type: MessageUpdateType.Stream, token: "word ".repeat(500) },
+		];
+		let nowMs = 0;
+		await collect(
+			smoothStreamUpdates(fromArray(source), {
+				minDelayMs: 5,
+				maxDelayMs: 80,
+				minRateCharsPerMs: 0.3,
+				maxBufferedMs: 400,
+				_internal: {
+					now: () => nowMs,
+					sleep: async (ms: number) => {
+						nowMs += ms;
+					},
+					detectChunk: (buffer) => /\S+\s+/.exec(buffer)?.[0] ?? null,
+				},
+			})
+		);
+
+		expect(nowMs).toBeLessThan(1500);
+	});
+
+	it("skips empty tokens gracefully", async () => {
+		const source: MessageUpdate[] = [
+			{ type: MessageUpdateType.Stream, token: "" },
+			{ type: MessageUpdateType.Stream, token: "hello " },
+			{ type: MessageUpdateType.Stream, token: "" },
+			{ type: MessageUpdateType.Stream, token: "world!" },
+			{ type: MessageUpdateType.Status, status: MessageUpdateStatus.Finished },
+		];
+
+		const updates = await collect(
+			smoothStreamUpdates(fromArray(source), { minDelayMs: 0, maxDelayMs: 0 })
+		);
+		expect(streamText(updates)).toBe("hello world!");
+	});
+});
+
+describe("applyStreamingMode", () => {
+	it("keeps stream unchanged for raw mode", async () => {
+		const source: MessageUpdate[] = [
+			{ type: MessageUpdateType.Stream, token: "Hello" },
+			{ type: MessageUpdateType.Status, status: MessageUpdateStatus.Finished },
+		];
+
+		const raw = await collect(applyStreamingMode(fromArray(source), "raw"));
+
+		expect(raw).toEqual(source);
+	});
+});
+
+describe("resolveStreamingMode", () => {
+	it("returns explicit streamingMode when set", () => {
+		expect(resolveStreamingMode({ streamingMode: "raw" })).toBe("raw");
+		expect(resolveStreamingMode({ streamingMode: "smooth" })).toBe("smooth");
+	});
+
+	it("defaults to smooth when unset", () => {
+		expect(resolveStreamingMode({})).toBe("smooth");
+	});
+
+	it("maps unsupported legacy values to smooth", () => {
+		expect(resolveStreamingMode({ streamingMode: "final" })).toBe("smooth");
+	});
+});

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

@@ -0,0 +1,324 @@
+import type { MessageFile } from "$lib/types/Message";
+import {
+	type MessageUpdate,
+	type MessageToolUpdate,
+	type MessageToolCallUpdate,
+	type MessageToolResultUpdate,
+	type MessageToolErrorUpdate,
+	type MessageToolProgressUpdate,
+	MessageUpdateType,
+	MessageToolUpdateType,
+} from "$lib/types/MessageUpdate";
+import type { StreamingMode } from "$lib/types/Settings";
+import type { KeyValuePair } from "$lib/types/Tool";
+
+type MessageUpdateRequestOptions = {
+	base: string;
+	inputs?: string;
+	messageId?: string;
+	isRetry: boolean;
+	isContinue?: boolean;
+	files?: MessageFile[];
+	// Optional: pass selected MCP server names (client-side selection)
+	selectedMcpServerNames?: string[];
+	// Optional: pass selected MCP server configs (for custom client-defined servers)
+	selectedMcpServers?: Array<{ name: string; url: string; headers?: KeyValuePair[] }>;
+	streamingMode?: StreamingMode;
+	autopilot?: boolean;
+};
+
+type ChunkDetector = (buffer: string) => string | null;
+
+type SmoothStreamConfig = {
+	minDelayMs?: number;
+	maxDelayMs?: number;
+	minRateCharsPerMs?: number;
+	maxBufferedMs?: number;
+	_internal?: {
+		now?: () => number;
+		sleep?: (ms: number) => Promise<void>;
+		detectChunk?: ChunkDetector;
+	};
+};
+
+export async function fetchMessageUpdates(
+	conversationId: string,
+	opts: MessageUpdateRequestOptions,
+	abortSignal: AbortSignal
+): Promise<AsyncGenerator<MessageUpdate>> {
+	const abortController = new AbortController();
+	abortSignal.addEventListener("abort", () => abortController.abort());
+
+	const form = new FormData();
+
+	const optsJSON = JSON.stringify({
+		inputs: opts.inputs,
+		id: opts.messageId,
+		is_retry: opts.isRetry,
+		is_continue: Boolean(opts.isContinue),
+		// Will be ignored server-side if unsupported
+		selectedMcpServerNames: opts.selectedMcpServerNames,
+		selectedMcpServers: opts.selectedMcpServers,
+		autopilot: opts.autopilot,
+	});
+
+	opts.files?.forEach((file) => {
+		const name = file.type + ";" + file.name;
+
+		form.append("files", new File([file.value], name, { type: file.mime }));
+	});
+
+	form.append("data", optsJSON);
+
+	const response = await fetch(`${opts.base}/conversation/${conversationId}`, {
+		method: "POST",
+		body: form,
+		signal: abortController.signal,
+	});
+
+	if (!response.ok) {
+		const errorMessage = await response
+			.json()
+			.then((obj) => obj.message)
+			.catch(() => `Request failed with status code ${response.status}: ${response.statusText}`);
+		throw Error(errorMessage);
+	}
+	if (!response.body) {
+		throw Error("Body not defined");
+	}
+
+	return applyStreamingMode(
+		endpointStreamToIterator(response, abortController),
+		opts.streamingMode ?? "smooth"
+	);
+}
+
+export function applyStreamingMode(
+	iterator: AsyncGenerator<MessageUpdate>,
+	streamingMode: StreamingMode
+): AsyncGenerator<MessageUpdate> {
+	if (streamingMode === "smooth") {
+		return smoothStreamUpdates(iterator);
+	}
+
+	// "raw" keeps source stream intact.
+	return iterator;
+}
+
+export function resolveStreamingMode(s: { streamingMode?: unknown }): StreamingMode {
+	return s.streamingMode === "raw" || s.streamingMode === "smooth" ? s.streamingMode : "smooth";
+}
+
+async function* endpointStreamToIterator(
+	response: Response,
+	abortController: AbortController
+): AsyncGenerator<MessageUpdate> {
+	const reader = response.body?.pipeThrough(new TextDecoderStream()).getReader();
+	if (!reader) throw Error("Response for endpoint had no body");
+
+	// Handle any cases where we must abort
+	reader.closed.then(() => abortController.abort());
+
+	// Handle logic for aborting
+	abortController.signal.addEventListener("abort", () => reader.cancel());
+
+	// ex) If the last response is => {"type": "stream", "token":
+	// It should be => {"type": "stream", "token": "Hello"} = prev_input_chunk + "Hello"}
+	let prevChunk = "";
+	while (!abortController.signal.aborted) {
+		const { done, value } = await reader.read();
+		if (done) {
+			abortController.abort();
+			break;
+		}
+		if (!value) continue;
+
+		const { messageUpdates, remainingText } = parseMessageUpdates(prevChunk + value);
+		prevChunk = remainingText;
+		for (const messageUpdate of messageUpdates) yield messageUpdate;
+	}
+}
+
+function parseMessageUpdates(value: string): {
+	messageUpdates: MessageUpdate[];
+	remainingText: string;
+} {
+	const inputs = value.split("\n");
+	const messageUpdates: MessageUpdate[] = [];
+	for (const input of inputs) {
+		try {
+			messageUpdates.push(JSON.parse(input) as MessageUpdate);
+		} catch (error) {
+			// in case of parsing error, we return what we were able to parse
+			if (error instanceof SyntaxError) {
+				return {
+					messageUpdates,
+					remainingText: inputs.at(-1) ?? "",
+				};
+			}
+		}
+	}
+	return { messageUpdates, remainingText: "" };
+}
+
+export async function* smoothStreamUpdates(
+	iterator: AsyncGenerator<MessageUpdate>,
+	{
+		minDelayMs = 5,
+		maxDelayMs = 80,
+		minRateCharsPerMs = 0.3,
+		maxBufferedMs = 400,
+		_internal: { now = () => performance.now(), sleep = defaultSleep, detectChunk } = {},
+	}: SmoothStreamConfig = {}
+): AsyncGenerator<MessageUpdate> {
+	const chunkDetector = detectChunk ?? createWordChunkDetector();
+	const eventTarget = new EventTarget();
+	const outputQueue: Array<{ update: MessageUpdate }> = [];
+	let producerDone = false;
+	let producerError: unknown = null;
+	let pendingBuffer = "";
+	let queuedStreamChars = 0;
+
+	const enqueue = (update: MessageUpdate) => {
+		if (update.type === MessageUpdateType.Stream) {
+			queuedStreamChars += update.token.length;
+		}
+		outputQueue.push({ update });
+		eventTarget.dispatchEvent(new Event("next"));
+	};
+
+	const flushPendingBuffer = () => {
+		if (pendingBuffer.length === 0) return;
+		enqueue({ type: MessageUpdateType.Stream, token: pendingBuffer });
+		pendingBuffer = "";
+	};
+
+	const producer = (async () => {
+		for await (const messageUpdate of iterator) {
+			if (messageUpdate.type !== MessageUpdateType.Stream) {
+				flushPendingBuffer();
+				enqueue(messageUpdate);
+				continue;
+			}
+
+			if (!messageUpdate.token) continue;
+
+			pendingBuffer += messageUpdate.token;
+			let chunk: string | null;
+			while ((chunk = chunkDetector(pendingBuffer)) !== null) {
+				if (chunk.length === 0) break;
+				enqueue({ type: MessageUpdateType.Stream, token: chunk });
+				pendingBuffer = pendingBuffer.slice(chunk.length);
+			}
+		}
+		flushPendingBuffer();
+	})()
+		.catch((error) => {
+			producerError = error;
+		})
+		.finally(() => {
+			producerDone = true;
+			eventTarget.dispatchEvent(new Event("next"));
+		});
+
+	// Character-rate targeting consumer
+	let totalCharsEmitted = 0;
+	let firstEmitAt: number | null = null;
+
+	while (!producerDone || outputQueue.length > 0) {
+		if (outputQueue.length === 0) {
+			await waitForEvent(eventTarget, "next");
+			continue;
+		}
+
+		const next = outputQueue.shift();
+		if (!next) continue;
+
+		if (next.update.type === MessageUpdateType.Stream) {
+			const tokenLen = next.update.token.length;
+			queuedStreamChars = Math.max(0, queuedStreamChars - tokenLen);
+			totalCharsEmitted += tokenLen;
+
+			if (firstEmitAt === null) firstEmitAt = now();
+
+			const elapsedMs = now() - firstEmitAt;
+			const currentRate = elapsedMs > 0 ? totalCharsEmitted / elapsedMs : 0;
+			const backlogChars = tokenLen + queuedStreamChars;
+			const backlogRate = maxBufferedMs > 0 ? backlogChars / maxBufferedMs : 0;
+			const targetRate = Math.max(currentRate, minRateCharsPerMs, backlogRate);
+			const rawDelay = tokenLen / targetRate;
+			const underBacklogPressure = backlogRate > minRateCharsPerMs;
+			const effectiveMinDelayMs = underBacklogPressure ? 0 : minDelayMs;
+			const delayMs = Math.round(Math.max(effectiveMinDelayMs, Math.min(maxDelayMs, rawDelay)));
+
+			if (delayMs > 0) {
+				await sleep(delayMs);
+			}
+		}
+
+		yield next.update;
+	}
+
+	await producer;
+	if (producerError) throw producerError;
+}
+
+function createWordChunkDetector(): ChunkDetector {
+	if (typeof Intl !== "undefined" && typeof Intl.Segmenter === "function") {
+		const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+		return (buffer: string): string | null => {
+			if (buffer.length === 0) return null;
+			let cursor = 0;
+			let boundary = 0;
+			let sawWordLike = false;
+
+			for (const part of segmenter.segment(buffer)) {
+				cursor += part.segment.length;
+				if (part.isWordLike) {
+					sawWordLike = true;
+					continue;
+				}
+				if (sawWordLike) {
+					boundary = cursor;
+					break;
+				}
+			}
+
+			return boundary > 0 ? buffer.slice(0, boundary) : null;
+		};
+	}
+
+	const wordWithTrailingBoundary = /\S+\s+/m;
+	return (buffer: string): string | null => {
+		const match = wordWithTrailingBoundary.exec(buffer);
+		if (!match) return null;
+		return buffer.slice(0, match.index) + match[0];
+	};
+}
+
+// Tool update type guards for UI rendering
+export const isMessageToolUpdate = (update: MessageUpdate): update is MessageToolUpdate =>
+	update.type === MessageUpdateType.Tool;
+
+export const isMessageToolCallUpdate = (update: MessageUpdate): update is MessageToolCallUpdate =>
+	isMessageToolUpdate(update) && update.subtype === MessageToolUpdateType.Call;
+
+export const isMessageToolResultUpdate = (
+	update: MessageUpdate
+): update is MessageToolResultUpdate =>
+	isMessageToolUpdate(update) && update.subtype === MessageToolUpdateType.Result;
+
+export const isMessageToolErrorUpdate = (update: MessageUpdate): update is MessageToolErrorUpdate =>
+	isMessageToolUpdate(update) && update.subtype === MessageToolUpdateType.Error;
+
+export const isMessageToolProgressUpdate = (
+	update: MessageUpdate
+): update is MessageToolProgressUpdate =>
+	isMessageToolUpdate(update) && update.subtype === MessageToolUpdateType.Progress;
+
+const defaultSleep = (ms: number): Promise<void> =>
+	new Promise((resolve) => setTimeout(resolve, ms));
+const waitForEvent = (eventTarget: EventTarget, eventName: string) =>
+	new Promise<boolean>((resolve) =>
+		eventTarget.addEventListener(eventName, () => resolve(true), { once: true })
+	);

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

@@ -0,0 +1,56 @@
+// Lightweight MIME helpers to avoid new dependencies.
+
+const EXTENSION_TO_MIME: Record<string, string> = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpe: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	pdf: "application/pdf",
+	txt: "text/plain",
+	csv: "text/csv",
+	json: "application/json",
+	mp3: "audio/mpeg",
+	wav: "audio/wav",
+	ogg: "audio/ogg",
+	mp4: "video/mp4",
+	mov: "video/quicktime",
+	webm: "video/webm",
+	zip: "application/zip",
+	gz: "application/gzip",
+	tgz: "application/gzip",
+	tar: "application/x-tar",
+	html: "text/html",
+	htm: "text/html",
+	md: "text/markdown",
+};
+
+export function guessMimeFromUrl(url: string): string | undefined {
+	try {
+		const pathname = new URL(url).pathname;
+		const ext = pathname.split(".").pop()?.toLowerCase();
+		if (ext && EXTENSION_TO_MIME[ext]) return EXTENSION_TO_MIME[ext];
+	} catch {
+		/* ignore */
+	}
+	return undefined;
+}
+
+export function pickSafeMime(
+	forwardedType: string | null,
+	blobType: string | undefined,
+	url: string
+): string {
+	const inferred = guessMimeFromUrl(url);
+	if (forwardedType) return forwardedType;
+	if (
+		inferred &&
+		(!blobType || blobType === "application/octet-stream" || blobType.startsWith("text/plain"))
+	) {
+		return inferred;
+	}
+	if (blobType) return blobType;
+	return inferred || "application/octet-stream";
+}

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

@@ -0,0 +1,14 @@
+import type { Model } from "$lib/types/Model";
+
+export const findCurrentModel = (
+	models: Model[],
+	_oldModels: { id: string; transferTo?: string }[] = [],
+	id?: string
+): Model => {
+	if (id) {
+		const direct = models.find((m) => m.id === id);
+		if (direct) return direct;
+	}
+
+	return models[0];
+};