@aigentic/ruflo 3.7.0-alpha.69

package/src/ruvocal/src/lib/server/router/arch.ts

@@ -0,0 +1,230 @@
+import { config } from "$lib/server/config";
+import { logger } from "$lib/server/logger";
+import type { EndpointMessage } from "../endpoints/endpoints";
+import type { Route, RouteConfig, RouteSelection } from "./types";
+import { getRoutes } from "./policy";
+import { getApiToken } from "$lib/server/apiToken";
+
+const DEFAULT_LAST_TURNS = 16;
+
+/**
+ * Trim a message by keeping start and end, replacing middle with minimal indicator.
+ * Uses simple ellipsis since router only needs context for intent classification, not exact content.
+ * @param content - The message content to trim
+ * @param maxLength - Maximum total length (including indicator)
+ * @returns Trimmed content with start, ellipsis, and end
+ */
+function trimMiddle(content: string, maxLength: number): string {
+	if (content.length <= maxLength) return content;
+
+	const indicator = "…";
+	const availableLength = maxLength - indicator.length;
+
+	if (availableLength <= 0) {
+		// If no room even for indicator, just hard truncate
+		return content.slice(0, maxLength);
+	}
+
+	// Reserve more space for the start (typically contains context)
+	const startLength = Math.ceil(availableLength * 0.6);
+	const endLength = availableLength - startLength;
+
+	// Bug fix: slice(-0) returns entire string, so check for endLength <= 0
+	if (endLength <= 0) {
+		// Not enough space for end portion, just use start + indicator
+		return content.slice(0, availableLength) + indicator;
+	}
+
+	const start = content.slice(0, startLength);
+	const end = content.slice(-endLength);
+
+	return start + indicator + end;
+}
+
+const PROMPT_TEMPLATE = `
+You are a helpful assistant designed to find the best suited route.
+You are provided with route description within <routes></routes> XML tags:
+
+<routes>
+
+{routes}
+
+</routes>
+
+<conversation>
+
+{conversation}
+
+</conversation>
+
+Your task is to decide which route is best suit with user intent on the conversation in <conversation></conversation> XML tags.
+
+Follow those instructions:
+1. Use prior turns to choose the best route for the current message if needed.
+2. If no route match the full conversation respond with other route {"route": "other"}.
+3. Analyze the route descriptions and find the best match route for user latest intent.
+4. Respond only with the route name that best matches the user's request, using the exact name in the <routes> block.
+Based on your analysis, provide your response in the following JSON format if you decide to match any route:
+{"route": "route_name"}
+`.trim();
+
+function lastNTurns<T>(arr: T[], n = DEFAULT_LAST_TURNS) {
+	if (!Array.isArray(arr)) return [] as T[];
+	return arr.slice(-n);
+}
+
+function toRouterPrompt(messages: EndpointMessage[], routes: Route[]) {
+	const simpleRoutes: RouteConfig[] = routes.map((r) => ({
+		name: r.name,
+		description: r.description,
+	}));
+	const maxAssistantLength = parseInt(config.LLM_ROUTER_MAX_ASSISTANT_LENGTH || "1000", 10);
+	const maxPrevUserLength = parseInt(config.LLM_ROUTER_MAX_PREV_USER_LENGTH || "1000", 10);
+
+	const convo = messages
+		.map((m) => ({ role: m.from, content: m.content }))
+		.filter((m) => typeof m.content === "string" && m.content.trim() !== "");
+
+	// Find the last user message index to preserve its full content
+	const lastUserIndex = convo.findLastIndex((m) => m.role === "user");
+
+	const trimmedConvo = convo.map((m, idx) => {
+		if (typeof m.content !== "string") return m;
+
+		// Trim assistant messages to reduce routing prompt size and improve latency
+		// Keep start and end for better context understanding
+		if (m.role === "assistant") {
+			return {
+				...m,
+				content: trimMiddle(m.content, maxAssistantLength),
+			};
+		}
+
+		// Trim previous user messages, but keep the latest user message full
+		// Keep start and end to preserve both context and question
+		if (m.role === "user" && idx !== lastUserIndex) {
+			return {
+				...m,
+				content: trimMiddle(m.content, maxPrevUserLength),
+			};
+		}
+
+		return m;
+	});
+
+	return PROMPT_TEMPLATE.replace("{routes}", JSON.stringify(simpleRoutes)).replace(
+		"{conversation}",
+		JSON.stringify(lastNTurns(trimmedConvo))
+	);
+}
+
+function parseRouteName(text: string): string | undefined {
+	if (!text) return;
+	try {
+		const obj = JSON.parse(text);
+		if (typeof obj?.route === "string" && obj.route.trim()) return obj.route.trim();
+	} catch {}
+	const m = text.match(/["']route["']\s*:\s*["']([^"']+)["']/);
+	if (m?.[1]) return m[1].trim();
+	try {
+		const obj = JSON.parse(text.replace(/'/g, '"'));
+		if (typeof obj?.route === "string" && obj.route.trim()) return obj.route.trim();
+	} catch {}
+	return;
+}
+
+export async function archSelectRoute(
+	messages: EndpointMessage[],
+	traceId: string | undefined,
+	locals: App.Locals | undefined
+): Promise<RouteSelection> {
+	const routes = await getRoutes();
+	const prompt = toRouterPrompt(messages, routes);
+
+	const baseURL = (config.LLM_ROUTER_ARCH_BASE_URL || "").replace(/\/$/, "");
+	const archModel = config.LLM_ROUTER_ARCH_MODEL || "router/omni";
+
+	if (!baseURL) {
+		logger.warn("LLM_ROUTER_ARCH_BASE_URL not set; routing will fail over to fallback.");
+		return { routeName: "arch_router_failure" };
+	}
+
+	const headers: HeadersInit = {
+		Authorization: `Bearer ${getApiToken(locals)}`,
+		"Content-Type": "application/json",
+		// Bill to organization if configured (HuggingChat only)
+		...(config.isHuggingChat && locals?.billingOrganization
+			? { "X-HF-Bill-To": locals.billingOrganization }
+			: {}),
+	};
+	const body = {
+		model: archModel,
+		messages: [{ role: "user", content: prompt }],
+		temperature: 0,
+		max_tokens: 16,
+		stream: false,
+	};
+
+	const ctrl = new AbortController();
+	const timeoutMs = Number(config.LLM_ROUTER_ARCH_TIMEOUT_MS || 10000);
+	const to = setTimeout(() => ctrl.abort(), timeoutMs);
+
+	try {
+		const resp = await fetch(`${baseURL}/chat/completions`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			signal: ctrl.signal,
+		});
+		clearTimeout(to);
+		if (!resp.ok) {
+			// Extract error message from response
+			let errorMessage = `arch-router ${resp.status}`;
+			try {
+				const errorData = await resp.json();
+				// Try to extract message from OpenAI-style error format
+				if (errorData.error?.message) {
+					errorMessage = errorData.error.message;
+				} else if (errorData.message) {
+					errorMessage = errorData.message;
+				}
+			} catch {
+				// If JSON parsing fails, use status text
+				errorMessage = resp.statusText || errorMessage;
+			}
+
+			logger.warn(
+				{ status: resp.status, error: errorMessage, traceId },
+				"[arch] router returned error"
+			);
+
+			return {
+				routeName: "arch_router_failure",
+				error: {
+					message: errorMessage,
+					statusCode: resp.status,
+				},
+			};
+		}
+		const data: { choices: { message: { content: string } }[] } = await resp.json();
+		const text = (data?.choices?.[0]?.message?.content ?? "").toString().trim();
+		const raw = parseRouteName(text);
+
+		const other = config.LLM_ROUTER_OTHER_ROUTE || "casual_conversation";
+		const chosen = raw === "other" ? other : raw || "casual_conversation";
+		const exists = routes.some((r) => r.name === chosen);
+		return { routeName: exists ? chosen : "casual_conversation" };
+	} catch (e) {
+		clearTimeout(to);
+		const err = e as Error;
+		logger.warn({ err: String(e), traceId }, "arch router selection failed");
+
+		// Return error with context but no status code (network/timeout errors)
+		return {
+			routeName: "arch_router_failure",
+			error: {
+				message: err.message || String(e),
+			},
+		};
+	}
+}

package/src/ruvocal/src/lib/server/router/endpoint.ts

@@ -0,0 +1,316 @@
+import type {
+	Endpoint,
+	EndpointParameters,
+	EndpointMessage,
+	TextGenerationStreamOutputSimplified,
+} from "../endpoints/endpoints";
+import endpoints from "../endpoints/endpoints";
+import type { ProcessedModel } from "../models";
+import { config } from "$lib/server/config";
+import { logger } from "$lib/server/logger";
+import { archSelectRoute } from "./arch";
+import { getRoutes, resolveRouteModels } from "./policy";
+import { getApiToken } from "$lib/server/apiToken";
+import { ROUTER_FAILURE } from "./types";
+import {
+	hasActiveToolsSelection,
+	isRouterToolsBypassEnabled,
+	pickToolsCapableModel,
+	ROUTER_TOOLS_ROUTE,
+} from "./toolsRoute";
+import { getConfiguredMultimodalModelId } from "./multimodal";
+
+const REASONING_BLOCK_REGEX = /<think>[\s\S]*?(?:<\/think>|$)/g;
+
+const ROUTER_MULTIMODAL_ROUTE = "multimodal";
+
+// Cache models at module level to avoid redundant dynamic imports on every request
+let cachedModels: ProcessedModel[] | undefined;
+
+async function getModels(): Promise<ProcessedModel[]> {
+	if (!cachedModels) {
+		const mod = await import("../models");
+		cachedModels = (mod as { models: ProcessedModel[] }).models;
+	}
+	return cachedModels;
+}
+
+/**
+ * Custom error class that preserves HTTP status codes
+ */
+class HTTPError extends Error {
+	constructor(
+		message: string,
+		public statusCode?: number
+	) {
+		super(message);
+		this.name = "HTTPError";
+	}
+}
+
+/**
+ * Extract the actual error message and status from OpenAI SDK errors or other upstream errors
+ */
+function extractUpstreamError(error: unknown): { message: string; statusCode?: number } {
+	// Check if it's an OpenAI APIError with structured error info
+	if (error && typeof error === "object") {
+		const err = error as Record<string, unknown>;
+
+		// OpenAI SDK error with error.error.message and status
+		if (
+			err.error &&
+			typeof err.error === "object" &&
+			"message" in err.error &&
+			typeof err.error.message === "string"
+		) {
+			return {
+				message: err.error.message,
+				statusCode: typeof err.status === "number" ? err.status : undefined,
+			};
+		}
+
+		// HTTPError or error with statusCode
+		if (typeof err.statusCode === "number" && typeof err.message === "string") {
+			return { message: err.message, statusCode: err.statusCode };
+		}
+
+		// Error with status field
+		if (typeof err.status === "number" && typeof err.message === "string") {
+			return { message: err.message, statusCode: err.status };
+		}
+
+		// Direct error message
+		if (typeof err.message === "string") {
+			return { message: err.message };
+		}
+	}
+
+	return { message: String(error) };
+}
+
+/**
+ * Determines if an error is a policy/entitlement error that should be shown to users immediately
+ * (vs transient errors that should trigger fallback)
+ */
+function isPolicyError(statusCode?: number): boolean {
+	if (!statusCode) return false;
+	// 400: Bad Request, 402: Payment Required, 401: Unauthorized, 403: Forbidden
+	return statusCode === 400 || statusCode === 401 || statusCode === 402 || statusCode === 403;
+}
+
+function stripReasoningBlocks(text: string): string {
+	const stripped = text.replace(REASONING_BLOCK_REGEX, "");
+	return stripped === text ? text : stripped.trim();
+}
+
+function stripReasoningFromMessage(message: EndpointMessage): EndpointMessage {
+	const content =
+		typeof message.content === "string" ? stripReasoningBlocks(message.content) : message.content;
+	return {
+		...message,
+		content,
+	};
+}
+
+/**
+ * Create an Endpoint that performs route selection via Arch and then forwards
+ * to the selected model (with fallbacks) using the OpenAI-compatible endpoint.
+ */
+export async function makeRouterEndpoint(routerModel: ProcessedModel): Promise<Endpoint> {
+	return async function routerEndpoint(params: EndpointParameters) {
+		const routes = await getRoutes();
+		const sanitizedMessages = params.messages.map(stripReasoningFromMessage);
+		const routerMultimodalEnabled =
+			(config.LLM_ROUTER_ENABLE_MULTIMODAL || "").toLowerCase() === "true";
+		const routerToolsEnabled = isRouterToolsBypassEnabled();
+		const hasImageInput = sanitizedMessages.some((message) =>
+			(message.files ?? []).some(
+				(file) => typeof file?.mime === "string" && file.mime.startsWith("image/")
+			)
+		);
+		// Tools are considered "active" if the client indicated any enabled MCP server
+		const hasToolsActive = hasActiveToolsSelection(params.locals);
+
+		// Helper to create an OpenAI endpoint for a specific candidate model id
+		async function createCandidateEndpoint(candidateModelId: string): Promise<Endpoint> {
+			// Try to use the real candidate model config if present in chat-ui's model list
+			let modelForCall: ProcessedModel | undefined;
+			try {
+				const all = await getModels();
+				modelForCall = all?.find((m) => m.id === candidateModelId || m.name === candidateModelId);
+			} catch (e) {
+				logger.warn({ err: String(e) }, "[router] failed to load models for candidate lookup");
+			}
+
+			if (!modelForCall) {
+				// Fallback: clone router model with candidate id
+				modelForCall = {
+					...routerModel,
+					id: candidateModelId,
+					name: candidateModelId,
+					displayName: candidateModelId,
+				} as ProcessedModel;
+			}
+
+			return endpoints.openai({
+				type: "openai",
+				baseURL: (config.OPENAI_BASE_URL || "https://router.huggingface.co/v1").replace(/\/$/, ""),
+				apiKey: getApiToken(params.locals),
+				model: modelForCall,
+				// Ensure streaming path is used
+				streamingSupported: true,
+			});
+		}
+
+		// Yield router metadata for immediate UI display, using the actual candidate
+		async function* metadataThenStream(
+			gen: AsyncGenerator<TextGenerationStreamOutputSimplified>,
+			actualModel: string,
+			selectedRoute: string
+		) {
+			yield {
+				token: { id: 0, text: "", special: true, logprob: 0 },
+				generated_text: null,
+				details: null,
+				routerMetadata: { route: selectedRoute, model: actualModel },
+			};
+			for await (const ev of gen) yield ev;
+		}
+
+		if (routerMultimodalEnabled && hasImageInput) {
+			let multimodalCandidate: string | undefined;
+			try {
+				const all = await getModels();
+				multimodalCandidate = getConfiguredMultimodalModelId(all);
+			} catch (e) {
+				logger.warn({ err: String(e) }, "[router] failed to load models for multimodal lookup");
+			}
+			if (!multimodalCandidate) {
+				throw new Error(
+					"Router multimodal is enabled but LLM_ROUTER_MULTIMODAL_MODEL is not correctly configured. Remove the image or configure a multimodal model via LLM_ROUTER_MULTIMODAL_MODEL."
+				);
+			}
+
+			try {
+				logger.info(
+					{ route: ROUTER_MULTIMODAL_ROUTE, model: multimodalCandidate },
+					"[router] multimodal input detected; bypassing Arch selection"
+				);
+				const ep = await createCandidateEndpoint(multimodalCandidate);
+				const gen = await ep({ ...params });
+				return metadataThenStream(gen, multimodalCandidate, ROUTER_MULTIMODAL_ROUTE);
+			} catch (e) {
+				const { message, statusCode } = extractUpstreamError(e);
+				logger.error(
+					{
+						route: ROUTER_MULTIMODAL_ROUTE,
+						model: multimodalCandidate,
+						err: message,
+						...(statusCode && { status: statusCode }),
+					},
+					"[router] multimodal fallback failed"
+				);
+				throw statusCode ? new HTTPError(message, statusCode) : new Error(message);
+			}
+		}
+
+		async function findToolsCandidateModel(): Promise<ProcessedModel | undefined> {
+			try {
+				const all = await getModels();
+				return pickToolsCapableModel(all);
+			} catch (e) {
+				logger.warn({ err: String(e) }, "[router] failed to load models for tools lookup");
+				return undefined;
+			}
+		}
+
+		if (routerToolsEnabled && hasToolsActive) {
+			const toolsModel = await findToolsCandidateModel();
+			const toolsCandidate = toolsModel?.id ?? toolsModel?.name;
+			if (!toolsCandidate) {
+				// No tool-capable model found — continue with normal routing instead of hard failing
+			} else {
+				try {
+					logger.info(
+						{ route: ROUTER_TOOLS_ROUTE, model: toolsCandidate },
+						"[router] tools active; bypassing Arch selection"
+					);
+					const ep = await createCandidateEndpoint(toolsCandidate);
+					const gen = await ep({ ...params });
+					return metadataThenStream(gen, toolsCandidate, ROUTER_TOOLS_ROUTE);
+				} catch (e) {
+					const { message, statusCode } = extractUpstreamError(e);
+					const logData = {
+						route: ROUTER_TOOLS_ROUTE,
+						model: toolsCandidate,
+						err: message,
+						...(statusCode && { status: statusCode }),
+					};
+					if (statusCode === 402) {
+						logger.warn(logData, "[router] tools fallback failed due to payment required");
+					} else {
+						logger.error(logData, "[router] tools fallback failed");
+					}
+					throw statusCode ? new HTTPError(message, statusCode) : new Error(message);
+				}
+			}
+		}
+
+		const routeSelection = await archSelectRoute(sanitizedMessages, undefined, params.locals);
+
+		// If arch router failed with an error, only hard-fail for policy errors (402/401/403)
+		// For transient errors (5xx, timeouts, network), allow fallback to continue
+		if (routeSelection.routeName === ROUTER_FAILURE && routeSelection.error) {
+			const { message, statusCode } = routeSelection.error;
+
+			if (isPolicyError(statusCode)) {
+				// Policy errors should be surfaced to the user immediately (e.g., subscription required)
+				logger.error(
+					{ err: message, ...(statusCode && { status: statusCode }) },
+					"[router] arch router failed with policy error, propagating to client"
+				);
+				throw statusCode ? new HTTPError(message, statusCode) : new Error(message);
+			}
+
+			// Transient errors: log and continue to fallback
+			logger.warn(
+				{ err: message, ...(statusCode && { status: statusCode }) },
+				"[router] arch router failed with transient error, attempting fallback"
+			);
+		}
+
+		const fallbackModel = config.LLM_ROUTER_FALLBACK_MODEL || routerModel.id;
+		const { candidates } = resolveRouteModels(routeSelection.routeName, routes, fallbackModel);
+
+		let lastErr: unknown = undefined;
+		for (const candidate of candidates) {
+			try {
+				logger.info(
+					{ route: routeSelection.routeName, model: candidate },
+					"[router] trying candidate"
+				);
+				const ep = await createCandidateEndpoint(candidate);
+				const gen = await ep({ ...params });
+				return metadataThenStream(gen, candidate, routeSelection.routeName);
+			} catch (e) {
+				lastErr = e;
+				const { message: errMsg, statusCode: errStatus } = extractUpstreamError(e);
+				logger.warn(
+					{
+						route: routeSelection.routeName,
+						model: candidate,
+						err: errMsg,
+						...(errStatus && { status: errStatus }),
+					},
+					"[router] candidate failed"
+				);
+				continue;
+			}
+		}
+
+		// Exhausted all candidates — throw to signal upstream failure
+		// Forward the upstream error to the client
+		const { message, statusCode } = extractUpstreamError(lastErr);
+		throw statusCode ? new HTTPError(message, statusCode) : new Error(message);
+	};
+}

package/src/ruvocal/src/lib/server/router/multimodal.ts

@@ -0,0 +1,28 @@
+import { config } from "$lib/server/config";
+import type { ProcessedModel } from "../models";
+
+/**
+ * Returns the configured multimodal model when it exists and is valid.
+ * - Requires LLM_ROUTER_MULTIMODAL_MODEL to be set (id or name).
+ * - Ignores router aliases and non-multimodal models.
+ */
+export function findConfiguredMultimodalModel(
+	models: ProcessedModel[] | undefined
+): ProcessedModel | undefined {
+	const preferredModelId = (config.LLM_ROUTER_MULTIMODAL_MODEL || "").trim();
+	if (!preferredModelId || !models?.length) return undefined;
+
+	return models.find(
+		(candidate) =>
+			(candidate.id === preferredModelId || candidate.name === preferredModelId) &&
+			!candidate.isRouter &&
+			candidate.multimodal
+	);
+}
+
+export function getConfiguredMultimodalModelId(
+	models: ProcessedModel[] | undefined
+): string | undefined {
+	const model = findConfiguredMultimodalModel(models);
+	return model?.id ?? model?.name;
+}

package/src/ruvocal/src/lib/server/router/policy.ts

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+import { config } from "$lib/server/config";
+import type { Route } from "./types";
+
+let ROUTES: Route[] = [];
+let loaded = false;
+
+export async function loadPolicy(): Promise<Route[]> {
+	const path = config.LLM_ROUTER_ROUTES_PATH;
+	const text = await readFile(path, "utf8");
+	const arr = JSON.parse(text) as Route[];
+	if (!Array.isArray(arr)) {
+		throw new Error("Routes config must be a flat array of routes");
+	}
+	const seen = new Set<string>();
+	for (const r of arr) {
+		if (!r?.name || !r?.description || !r?.primary_model) {
+			throw new Error(`Invalid route entry: ${JSON.stringify(r)}`);
+		}
+		if (seen.has(r.name)) {
+			throw new Error(`Duplicate route name: ${r.name}`);
+		}
+		seen.add(r.name);
+	}
+	ROUTES = arr;
+	loaded = true;
+	return ROUTES;
+}
+
+export async function getRoutes(): Promise<Route[]> {
+	if (!loaded) await loadPolicy();
+	return ROUTES;
+}
+
+export function resolveRouteModels(
+	routeName: string,
+	routes: Route[],
+	fallbackModel: string
+): { candidates: string[] } {
+	if (routeName === "arch_router_failure") {
+		return { candidates: [fallbackModel] };
+	}
+	const sel =
+		routes.find((r) => r.name === routeName) ||
+		routes.find((r) => r.name === "casual_conversation");
+	if (!sel) return { candidates: [fallbackModel] };
+	const fallbacks = Array.isArray(sel.fallback_models) ? sel.fallback_models : [];
+	return { candidates: [sel.primary_model, ...fallbacks] };
+}

package/src/ruvocal/src/lib/server/router/toolsRoute.ts

@@ -0,0 +1,51 @@
+import { config } from "$lib/server/config";
+import { logger } from "$lib/server/logger";
+import type { ProcessedModel } from "../models";
+
+export const ROUTER_TOOLS_ROUTE = "agentic";
+
+type LocalsWithMcp = App.Locals & {
+	mcp?: {
+		selectedServers?: unknown[];
+		selectedServerNames?: unknown[];
+	};
+};
+
+export function isRouterToolsBypassEnabled(): boolean {
+	return (config.LLM_ROUTER_ENABLE_TOOLS || "").toLowerCase() === "true";
+}
+
+export function hasActiveToolsSelection(locals: App.Locals | undefined): boolean {
+	try {
+		const reqMcp = (locals as LocalsWithMcp | undefined)?.mcp;
+		const byConfig =
+			Array.isArray(reqMcp?.selectedServers) && (reqMcp?.selectedServers?.length ?? 0) > 0;
+		const byName =
+			Array.isArray(reqMcp?.selectedServerNames) && (reqMcp?.selectedServerNames?.length ?? 0) > 0;
+		return Boolean(byConfig || byName);
+	} catch {
+		return false;
+	}
+}
+
+export function pickToolsCapableModel(
+	models: ProcessedModel[] | undefined
+): ProcessedModel | undefined {
+	const preferredRaw = (config as unknown as Record<string, string>).LLM_ROUTER_TOOLS_MODEL;
+	const preferred = preferredRaw?.trim();
+	if (!preferred) {
+		logger.warn("[router] tools bypass requested but LLM_ROUTER_TOOLS_MODEL is not set");
+		return undefined;
+	}
+	if (!models?.length) return undefined;
+	const found = models.find((m) => m.id === preferred || m.name === preferred);
+	if (!found) {
+		logger.warn(
+			{ configuredModel: preferred },
+			"[router] configured tools model not found; falling back to Arch routing"
+		);
+		return undefined;
+	}
+	logger.info({ model: found.id ?? found.name }, "[router] using configured tools model");
+	return found;
+}

package/src/ruvocal/src/lib/server/router/types.ts

@@ -0,0 +1,21 @@
+export interface Route {
+	name: string;
+	description: string;
+	primary_model: string;
+	fallback_models?: string[];
+}
+
+export interface RouteConfig {
+	name: string;
+	description: string;
+}
+
+export interface RouteSelection {
+	routeName: string;
+	error?: {
+		message: string;
+		statusCode?: number;
+	};
+}
+
+export const ROUTER_FAILURE = "arch_router_failure";