@aigentic/ruflo 3.7.0-alpha.69

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

@@ -0,0 +1,23 @@
+import { config } from "$lib/server/config";
+import { logger } from "$lib/server/logger";
+
+export async function sendSlack(text: string) {
+	if (!config.WEBHOOK_URL_REPORT_ASSISTANT) {
+		logger.warn("WEBHOOK_URL_REPORT_ASSISTANT is not set, tried to send a slack message.");
+		return;
+	}
+
+	const res = await fetch(config.WEBHOOK_URL_REPORT_ASSISTANT, {
+		method: "POST",
+		headers: {
+			"Content-type": "application/json",
+		},
+		body: JSON.stringify({
+			text,
+		}),
+	});
+
+	if (!res.ok) {
+		logger.error(`Webhook message failed. ${res.statusText} ${res.text}`);
+	}
+}

package/src/ruvocal/src/lib/server/textGeneration/generate.ts

@@ -0,0 +1,258 @@
+import { config } from "$lib/server/config";
+import {
+	MessageReasoningUpdateType,
+	MessageUpdateType,
+	type MessageUpdate,
+} from "$lib/types/MessageUpdate";
+import { AbortedGenerations } from "../abortedGenerations";
+import type { TextGenerationContext } from "./types";
+import type { EndpointMessage } from "../endpoints/endpoints";
+import { generateFromDefaultEndpoint } from "../generateFromDefaultEndpoint";
+import { generateSummaryOfReasoning } from "./reasoning";
+import { logger } from "../logger";
+
+type GenerateContext = Omit<TextGenerationContext, "messages"> & { messages: EndpointMessage[] };
+
+export async function* generate(
+	{
+		model,
+		endpoint,
+		conv,
+		messages,
+		assistant,
+		promptedAt,
+		forceMultimodal,
+		provider,
+		locals,
+		abortController,
+	}: GenerateContext,
+	preprompt?: string
+): AsyncIterable<MessageUpdate> {
+	// Reasoning mode support
+	let reasoning = false;
+	let reasoningBuffer = "";
+	let lastReasoningUpdate = new Date();
+	let status = "";
+	const startTime = new Date();
+	const modelReasoning = Reflect.get(model, "reasoning") as
+		| { type: string; beginToken?: string; endToken?: string; regex?: string }
+		| undefined;
+	if (
+		modelReasoning &&
+		(modelReasoning.type === "regex" ||
+			modelReasoning.type === "summarize" ||
+			(modelReasoning.type === "tokens" && modelReasoning.beginToken === ""))
+	) {
+		// Starts in reasoning mode and we extract the answer from the reasoning
+		reasoning = true;
+		yield {
+			type: MessageUpdateType.Reasoning,
+			subtype: MessageReasoningUpdateType.Status,
+			status: "Started reasoning...",
+		};
+	}
+
+	const stream = await endpoint({
+		messages,
+		preprompt,
+		generateSettings: assistant?.generateSettings,
+		// Allow user-level override to force multimodal
+		isMultimodal: (forceMultimodal ?? false) || model.multimodal,
+		conversationId: conv._id,
+		locals,
+		abortSignal: abortController.signal,
+		provider,
+	});
+
+	for await (const output of stream) {
+		// Check if this output contains router metadata. Emit if either:
+		// 1) route+model are present (router models), or
+		// 2) provider-only is present (non-router models exposing x-inference-provider)
+		if ("routerMetadata" in output && output.routerMetadata) {
+			const hasRouteModel = Boolean(output.routerMetadata.route && output.routerMetadata.model);
+			const hasProviderOnly = Boolean(output.routerMetadata.provider);
+			if (hasRouteModel || hasProviderOnly) {
+				yield {
+					type: MessageUpdateType.RouterMetadata,
+					route: output.routerMetadata.route || "",
+					model: output.routerMetadata.model || "",
+					provider:
+						(output.routerMetadata
+							.provider as unknown as import("@huggingface/inference").InferenceProvider) ||
+						undefined,
+				};
+				continue;
+			}
+		}
+		// text generation completed
+		if (output.generated_text) {
+			// If an abort happened just before final output, stop here and let
+			// the caller emit an interrupted final answer with partial text.
+			const abortTime = AbortedGenerations.getInstance().getAbortTime(conv._id.toString());
+			if (abortController.signal.aborted || (abortTime && abortTime > promptedAt)) {
+				if (!abortController.signal.aborted) {
+					abortController.abort();
+				}
+				break;
+			}
+
+			let interrupted =
+				!output.token.special && !model.parameters.stop?.includes(output.token.text);
+
+			let text = output.generated_text.trimEnd();
+			for (const stopToken of model.parameters.stop ?? []) {
+				if (!text.endsWith(stopToken)) continue;
+
+				interrupted = false;
+				text = text.slice(0, text.length - stopToken.length);
+			}
+
+			let finalAnswer = text;
+			if (modelReasoning && modelReasoning.type === "regex" && modelReasoning.regex) {
+				const regex = new RegExp(modelReasoning.regex);
+				finalAnswer = regex.exec(reasoningBuffer)?.[1] ?? text;
+			} else if (modelReasoning && modelReasoning.type === "summarize") {
+				yield {
+					type: MessageUpdateType.Reasoning,
+					subtype: MessageReasoningUpdateType.Status,
+					status: "Summarizing reasoning...",
+				};
+				try {
+					const summary = yield* generateFromDefaultEndpoint({
+						messages: [
+							{
+								from: "user",
+								content: `Question: ${messages[messages.length - 1].content}\n\nReasoning: ${reasoningBuffer}`,
+							},
+						],
+						preprompt: `Your task is to summarize concisely all your reasoning steps and then give the final answer. Keep it short, one short paragraph at most. If the reasoning steps explicitly include a code solution, make sure to include it in your answer.`,
+						modelId: Reflect.get(model, "id") as string | undefined,
+						locals,
+					});
+					finalAnswer = summary;
+					yield {
+						type: MessageUpdateType.Reasoning,
+						subtype: MessageReasoningUpdateType.Status,
+						status: `Done in ${Math.round((new Date().getTime() - startTime.getTime()) / 1000)}s.`,
+					};
+				} catch (e) {
+					finalAnswer = text;
+					logger.error(e, "Error generating summary of reasoning");
+				}
+			} else if (modelReasoning && modelReasoning.type === "tokens") {
+				// Remove the reasoning segment from final answer to avoid duplication
+				const beginIndex = modelReasoning.beginToken
+					? reasoningBuffer.indexOf(modelReasoning.beginToken)
+					: 0;
+				const endIndex = modelReasoning.endToken
+					? reasoningBuffer.lastIndexOf(modelReasoning.endToken)
+					: -1;
+
+				if (beginIndex !== -1 && endIndex !== -1 && modelReasoning.endToken) {
+					finalAnswer =
+						text.slice(0, beginIndex) + text.slice(endIndex + modelReasoning.endToken.length);
+				}
+			}
+
+			yield { type: MessageUpdateType.FinalAnswer, text: finalAnswer, interrupted };
+			continue;
+		}
+
+		if (modelReasoning && modelReasoning.type === "tokens") {
+			if (output.token.text === modelReasoning.beginToken) {
+				reasoning = true;
+				reasoningBuffer += output.token.text;
+				continue;
+			} else if (modelReasoning.endToken && output.token.text === modelReasoning.endToken) {
+				reasoning = false;
+				reasoningBuffer += output.token.text;
+				yield {
+					type: MessageUpdateType.Reasoning,
+					subtype: MessageReasoningUpdateType.Status,
+					status: `Done in ${Math.round((new Date().getTime() - startTime.getTime()) / 1000)}s.`,
+				};
+				continue;
+			}
+		}
+
+		// ignore special tokens
+		if (output.token.special) continue;
+
+		// pass down normal token
+		if (reasoning) {
+			reasoningBuffer += output.token.text;
+
+			if (modelReasoning && modelReasoning.type === "tokens" && modelReasoning.endToken) {
+				if (reasoningBuffer.lastIndexOf(modelReasoning.endToken) !== -1) {
+					const endTokenIndex = reasoningBuffer.lastIndexOf(modelReasoning.endToken);
+					const textBuffer = reasoningBuffer.slice(endTokenIndex + modelReasoning.endToken.length);
+					reasoningBuffer = reasoningBuffer.slice(
+						0,
+						endTokenIndex + modelReasoning.endToken.length + 1
+					);
+
+					yield {
+						type: MessageUpdateType.Reasoning,
+						subtype: MessageReasoningUpdateType.Stream,
+						token: output.token.text,
+					};
+					yield { type: MessageUpdateType.Stream, token: textBuffer };
+					yield {
+						type: MessageUpdateType.Reasoning,
+						subtype: MessageReasoningUpdateType.Status,
+						status: `Done in ${Math.round((new Date().getTime() - startTime.getTime()) / 1000)}s.`,
+					};
+					reasoning = false;
+					continue;
+				}
+			}
+
+			// yield status update if it has changed
+			if (status !== "") {
+				yield {
+					type: MessageUpdateType.Reasoning,
+					subtype: MessageReasoningUpdateType.Status,
+					status,
+				};
+				status = "";
+			}
+
+			// create a new status every ~4s (optional)
+			if (
+				Reflect.get(config, "REASONING_SUMMARY") === "true" &&
+				new Date().getTime() - lastReasoningUpdate.getTime() > 4000
+			) {
+				lastReasoningUpdate = new Date();
+				try {
+					generateSummaryOfReasoning(reasoningBuffer, model.id, locals).then((summary) => {
+						status = summary;
+					});
+				} catch (e) {
+					logger.error(e, "Error generating summary of reasoning");
+				}
+			}
+
+			yield {
+				type: MessageUpdateType.Reasoning,
+				subtype: MessageReasoningUpdateType.Stream,
+				token: output.token.text,
+			};
+		} else {
+			yield { type: MessageUpdateType.Stream, token: output.token.text };
+		}
+
+		// abort check
+		const date = AbortedGenerations.getInstance().getAbortTime(conv._id.toString());
+
+		if (date && date > promptedAt) {
+			logger.info(`Aborting generation for conversation ${conv._id}`);
+			if (!abortController.signal.aborted) {
+				abortController.abort();
+			}
+			break;
+		}
+
+		// no output check
+		if (!output) break;
+	}
+}

package/src/ruvocal/src/lib/server/textGeneration/index.ts

@@ -0,0 +1,96 @@
+import { preprocessMessages } from "../endpoints/preprocessMessages";
+
+import { generateTitleForConversation } from "./title";
+import {
+	type MessageUpdate,
+	MessageUpdateType,
+	MessageUpdateStatus,
+} from "$lib/types/MessageUpdate";
+import { generate } from "./generate";
+import { runMcpFlow } from "./mcp/runMcpFlow";
+import { mergeAsyncGenerators } from "$lib/utils/mergeAsyncGenerators";
+import type { TextGenerationContext } from "./types";
+
+async function* keepAlive(done: AbortSignal): AsyncGenerator<MessageUpdate, undefined, undefined> {
+	while (!done.aborted) {
+		yield {
+			type: MessageUpdateType.Status,
+			status: MessageUpdateStatus.KeepAlive,
+		};
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+}
+
+export async function* textGeneration(ctx: TextGenerationContext) {
+	const done = new AbortController();
+
+	const titleGen = generateTitleForConversation(ctx.conv, ctx.locals);
+	const textGen = textGenerationWithoutTitle(ctx, done);
+	const keepAliveGen = keepAlive(done.signal);
+
+	// keep alive until textGen is done
+
+	yield* mergeAsyncGenerators([titleGen, textGen, keepAliveGen]);
+}
+
+async function* textGenerationWithoutTitle(
+	ctx: TextGenerationContext,
+	done: AbortController
+): AsyncGenerator<MessageUpdate, undefined, undefined> {
+	yield {
+		type: MessageUpdateType.Status,
+		status: MessageUpdateStatus.Started,
+	};
+
+	const { conv, messages } = ctx;
+	const convId = conv._id;
+
+	const preprompt = conv.preprompt;
+
+	const processedMessages = await preprocessMessages(messages, convId);
+
+	// Try MCP tool flow first; fall back to default generation if not selected/available
+	try {
+		const mcpGen = runMcpFlow({
+			model: ctx.model,
+			conv,
+			messages: processedMessages,
+			assistant: ctx.assistant,
+			forceMultimodal: ctx.forceMultimodal,
+			forceTools: ctx.forceTools,
+			provider: ctx.provider,
+			locals: ctx.locals,
+			preprompt,
+			abortSignal: ctx.abortController.signal,
+			abortController: ctx.abortController,
+			promptedAt: ctx.promptedAt,
+			autopilot: ctx.autopilot,
+			autopilotMaxSteps: ctx.autopilotMaxSteps,
+		});
+
+		let step = await mcpGen.next();
+		while (!step.done) {
+			yield step.value;
+			step = await mcpGen.next();
+		}
+		const mcpResult = step.value;
+		if (mcpResult === "not_applicable") {
+			// fallback to normal text generation
+			yield* generate({ ...ctx, messages: processedMessages }, preprompt);
+		}
+		// If mcpResult is "completed" or "aborted", don't fall back
+	} catch (err) {
+		// Don't fall back on abort errors - user intentionally stopped
+		const isAbort =
+			ctx.abortController.signal.aborted ||
+			(err instanceof Error &&
+				(err.name === "AbortError" ||
+					err.name === "APIUserAbortError" ||
+					err.message.includes("Request was aborted")));
+		if (!isAbort) {
+			// On non-abort MCP error, fall back to normal generation
+			yield* generate({ ...ctx, messages: processedMessages }, preprompt);
+		}
+	}
+	done.abort();
+}

package/src/ruvocal/src/lib/server/textGeneration/mcp/fileRefs.ts

@@ -0,0 +1,155 @@
+import type { EndpointMessage } from "../../endpoints/endpoints";
+
+export type FileRefPayload = {
+	name: string;
+	mime: string;
+	base64: string;
+};
+
+export type RefKind = {
+	prefix: string;
+	matches: (mime: string) => boolean;
+	toDataUrl?: (payload: FileRefPayload) => string;
+};
+
+export type ResolvedFileRef = FileRefPayload & { refKind: RefKind };
+export type FileRefResolver = (ref: string) => ResolvedFileRef | undefined;
+
+const IMAGE_REF_KIND: RefKind = {
+	prefix: "image",
+	matches: (mime) => typeof mime === "string" && mime.startsWith("image/"),
+	toDataUrl: (payload) => `data:${payload.mime};base64,${payload.base64}`,
+};
+
+const DEFAULT_REF_KINDS: RefKind[] = [IMAGE_REF_KIND];
+
+/**
+ * Build a resolver that maps short ref strings (e.g. "image_1", "image_2") to the
+ * corresponding file payload across the whole conversation in chronological
+ * order of user uploads. (image_1 = first user-uploaded image, image_2 = second, etc.)
+ * Currently only images are exposed to end users, but the plumbing supports
+ * additional kinds later.
+ */
+export function buildFileRefResolver(
+	messages: EndpointMessage[],
+	refKinds: RefKind[] = DEFAULT_REF_KINDS
+): FileRefResolver | undefined {
+	if (!Array.isArray(refKinds) || refKinds.length === 0) return undefined;
+
+	// Bucket matched files by ref kind preserving conversation order (oldest -> newest)
+	const buckets = new Map<RefKind, FileRefPayload[]>();
+	for (const msg of messages) {
+		if (msg.from !== "user") continue;
+		for (const file of msg.files ?? []) {
+			const mime = file?.mime ?? "";
+			const kind = refKinds.find((k) => k.matches(mime));
+			if (!kind) continue;
+			const payload: FileRefPayload = { name: file.name, mime, base64: file.value };
+			const arr = buckets.get(kind) ?? [];
+			arr.push(payload);
+			buckets.set(kind, arr);
+		}
+	}
+
+	if (buckets.size === 0) return undefined;
+
+	const resolver: FileRefResolver = (ref) => {
+		if (!ref || typeof ref !== "string") return undefined;
+		const trimmed = ref.trim().toLowerCase();
+		for (const kind of refKinds) {
+			const match = new RegExp(`^${kind.prefix}_(\\d+)$`).exec(trimmed);
+			if (!match) continue;
+			const idx = Number(match[1]) - 1;
+			const files = buckets.get(kind) ?? [];
+			if (Number.isFinite(idx) && idx >= 0 && idx < files.length) {
+				const payload = files[idx];
+				return payload ? { ...payload, refKind: kind } : undefined;
+			}
+		}
+		return undefined;
+	};
+
+	return resolver;
+}
+
+export function buildImageRefResolver(messages: EndpointMessage[]): FileRefResolver | undefined {
+	return buildFileRefResolver(messages, [IMAGE_REF_KIND]);
+}
+
+type FieldRule = {
+	keys: string[];
+	action: "attachPayload" | "replaceWithDataUrl";
+	attachKey?: string;
+	allowedPrefixes?: string[]; // limit to specific ref kinds (e.g. ["image"])
+};
+
+const DEFAULT_FIELD_RULES: FieldRule[] = [
+	{
+		keys: ["image_ref"],
+		action: "attachPayload",
+		attachKey: "image",
+		allowedPrefixes: ["image"],
+	},
+	{
+		keys: ["input_image", "image", "image_url"],
+		action: "replaceWithDataUrl",
+		allowedPrefixes: ["image"],
+	},
+];
+
+/**
+ * Walk tool args and hydrate known ref fields while keeping logging lightweight.
+ * Only image refs are recognized for now to preserve current behavior.
+ */
+export function attachFileRefsToArgs(
+	argsObj: Record<string, unknown>,
+	resolveRef?: FileRefResolver,
+	fieldRules: FieldRule[] = DEFAULT_FIELD_RULES
+): void {
+	if (!resolveRef) return;
+
+	const visit = (node: unknown): void => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const v of node) visit(v);
+			return;
+		}
+
+		const obj = node as Record<string, unknown>;
+		for (const [key, value] of Object.entries(obj)) {
+			if (typeof value !== "string") {
+				if (value && typeof value === "object") visit(value);
+				continue;
+			}
+
+			const resolved = resolveRef(value);
+			if (!resolved) continue;
+
+			const rule = fieldRules.find((r) => r.keys.includes(key));
+			if (!rule) continue;
+			if (rule.allowedPrefixes && !rule.allowedPrefixes.includes(resolved.refKind.prefix)) continue;
+
+			if (rule.action === "attachPayload") {
+				const targetKey = rule.attachKey ?? "file";
+				if (
+					typeof obj[targetKey] !== "object" ||
+					obj[targetKey] === null ||
+					Array.isArray(obj[targetKey])
+				) {
+					obj[targetKey] = {
+						name: resolved.name,
+						mime: resolved.mime,
+						base64: resolved.base64,
+					};
+				}
+			} else if (rule.action === "replaceWithDataUrl") {
+				const toUrl =
+					resolved.refKind.toDataUrl ??
+					((p: FileRefPayload) => `data:${p.mime};base64,${p.base64}`);
+				obj[key] = toUrl(resolved);
+			}
+		}
+	};
+
+	visit(argsObj);
+}

package/src/ruvocal/src/lib/server/textGeneration/mcp/routerResolution.ts

@@ -0,0 +1,108 @@
+import { config } from "$lib/server/config";
+import { archSelectRoute } from "$lib/server/router/arch";
+import { getRoutes, resolveRouteModels } from "$lib/server/router/policy";
+import {
+	hasActiveToolsSelection,
+	isRouterToolsBypassEnabled,
+	pickToolsCapableModel,
+	ROUTER_TOOLS_ROUTE,
+} from "$lib/server/router/toolsRoute";
+import { findConfiguredMultimodalModel } from "$lib/server/router/multimodal";
+import type { EndpointMessage } from "../../endpoints/endpoints";
+import { stripReasoningFromMessageForRouting } from "../utils/routing";
+import type { ProcessedModel } from "../../models";
+import { logger } from "../../logger";
+
+export interface RouterResolutionInput {
+	model: ProcessedModel;
+	messages: EndpointMessage[];
+	conversationId: string;
+	hasImageInput: boolean;
+	locals: App.Locals | undefined;
+}
+
+export interface RouterResolutionResult {
+	runMcp: boolean;
+	targetModel: ProcessedModel;
+	candidateModelId?: string;
+	resolvedRoute?: string;
+}
+
+export async function resolveRouterTarget({
+	model,
+	messages,
+	conversationId,
+	hasImageInput,
+	locals,
+}: RouterResolutionInput): Promise<RouterResolutionResult> {
+	let targetModel = model;
+	let candidateModelId: string | undefined;
+	let resolvedRoute: string | undefined;
+	let runMcp = true;
+
+	if (!model.isRouter) {
+		return { runMcp, targetModel };
+	}
+
+	try {
+		const mod = await import("../../models");
+		const allModels = mod.models as ProcessedModel[];
+
+		if (hasImageInput) {
+			const multimodalCandidate = findConfiguredMultimodalModel(allModels);
+			if (!multimodalCandidate) {
+				runMcp = false;
+				logger.warn(
+					{ configuredModel: config.LLM_ROUTER_MULTIMODAL_MODEL },
+					"[mcp] multimodal input but configured model missing or invalid; skipping MCP route"
+				);
+			} else {
+				targetModel = multimodalCandidate;
+				candidateModelId = multimodalCandidate.id ?? multimodalCandidate.name;
+				resolvedRoute = "multimodal";
+			}
+		} else {
+			// If tools are enabled and at least one MCP server is active, prefer a tools-capable model
+			const toolsEnabled = isRouterToolsBypassEnabled();
+			const hasToolsActive = hasActiveToolsSelection(locals);
+
+			if (toolsEnabled && hasToolsActive) {
+				const found = pickToolsCapableModel(allModels);
+				if (found) {
+					targetModel = found;
+					candidateModelId = found.id ?? found.name;
+					resolvedRoute = ROUTER_TOOLS_ROUTE;
+					// Continue; runMcp remains true
+					return { runMcp, targetModel, candidateModelId, resolvedRoute };
+				}
+				// No tools-capable model found; fall back to normal Arch routing below
+			}
+			const routes = await getRoutes();
+			const sanitized = messages.map(stripReasoningFromMessageForRouting);
+			const { routeName } = await archSelectRoute(sanitized, conversationId, locals);
+			resolvedRoute = routeName;
+			const fallbackModel = config.LLM_ROUTER_FALLBACK_MODEL || model.id;
+			const { candidates } = resolveRouteModels(routeName, routes, fallbackModel);
+			const primaryCandidateId = candidates[0];
+			if (!primaryCandidateId || primaryCandidateId === fallbackModel) {
+				runMcp = false;
+			} else {
+				const found = allModels?.find(
+					(candidate) =>
+						candidate.id === primaryCandidateId || candidate.name === primaryCandidateId
+				);
+				if (found) {
+					targetModel = found;
+					candidateModelId = primaryCandidateId;
+				} else {
+					runMcp = false;
+				}
+			}
+		}
+	} catch (error) {
+		logger.warn({ err: String(error) }, "[mcp] routing preflight failed");
+		runMcp = false;
+	}
+
+	return { runMcp, targetModel, candidateModelId, resolvedRoute };
+}