miladyai 2.0.0-alpha.27

package/dist/runtime/embedding-manager-support.js

@@ -0,0 +1,185 @@
+import { __require } from "../_virtual/_rolldown/runtime.js";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import https from "node:https";
+
+//#region src/runtime/embedding-manager-support.ts
+const DEFAULT_IDLE_TIMEOUT_MS = 1800 * 1e3;
+const DEFAULT_MODELS_DIR = path.join(os.homedir(), ".eliza", "models");
+const EMBEDDING_META_DIR = process.env.MILAIDY_EMBEDDING_META_DIR ?? path.join(os.homedir(), ".milaidy", "state");
+const EMBEDDING_META_PATH = process.env.MILAIDY_EMBEDDING_META_PATH ?? path.join(EMBEDDING_META_DIR, "embedding-meta.json");
+let _logger;
+function getLogger() {
+	if (_logger) return _logger;
+	try {
+		const core = __require("@elizaos/core");
+		if (core?.logger) {
+			_logger = core.logger;
+			return _logger;
+		}
+	} catch {}
+	_logger = console;
+	return _logger;
+}
+function readEmbeddingMeta() {
+	try {
+		if (!fs.existsSync(EMBEDDING_META_PATH)) return null;
+		return JSON.parse(fs.readFileSync(EMBEDDING_META_PATH, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function writeEmbeddingMeta(meta) {
+	try {
+		fs.mkdirSync(EMBEDDING_META_DIR, { recursive: true });
+		fs.writeFileSync(EMBEDDING_META_PATH, JSON.stringify(meta, null, 2));
+	} catch (err) {
+		getLogger().warn(`[milaidy] Failed to write embedding metadata: ${err}`);
+	}
+}
+function checkDimensionMigration(model, dimensions) {
+	const log = getLogger();
+	const stored = readEmbeddingMeta();
+	if (stored && stored.dimensions !== dimensions) log.warn(`[milaidy] Embedding dimensions changed (${stored.dimensions} → ${dimensions}). Existing memory embeddings will be re-indexed on next access.`);
+	writeEmbeddingMeta({
+		model,
+		dimensions,
+		lastChanged: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function safeUnlink(filepath) {
+	try {
+		if (fs.existsSync(filepath)) fs.unlinkSync(filepath);
+	} catch {}
+}
+function getErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	if (error != null && typeof error === "object" && "message" in error && typeof error.message === "string") return error.message;
+	return String(error);
+}
+function isCorruptedModelLoadError(error) {
+	const message = getErrorMessage(error).toLowerCase();
+	return message.includes("failed to load model") || message.includes("data is not within the file bounds") || message.includes("tensor") && message.includes("is corrupted") || message.includes("model is corrupted");
+}
+function parseContentLength(contentLength) {
+	if (!contentLength || Array.isArray(contentLength)) return null;
+	const parsed = Number.parseInt(contentLength, 10);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+function isAllowedDownloadHost(hostname) {
+	return hostname === "huggingface.co" || hostname.endsWith(".huggingface.co");
+}
+function validateDownloadUrl(rawUrl) {
+	let parsed;
+	try {
+		parsed = new URL(rawUrl);
+	} catch {
+		throw new Error(`Download failed: invalid URL "${rawUrl}"`);
+	}
+	if (parsed.protocol !== "https:") throw new Error("Download failed: only https:// URLs are allowed");
+	if (!isAllowedDownloadHost(parsed.hostname.toLowerCase())) throw new Error(`Download failed: host "${parsed.hostname}" is not allowed`);
+	return parsed;
+}
+function sanitizeModelRepo(repo) {
+	const trimmed = repo.trim();
+	if (!/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(trimmed)) throw new Error(`Invalid embedding model repo: ${repo}`);
+	return trimmed;
+}
+function sanitizeModelFilename(filename) {
+	const trimmed = filename.trim();
+	if (!/^[A-Za-z0-9._-]+\.gguf$/i.test(trimmed)) throw new Error(`Invalid embedding model filename: ${filename}`);
+	return trimmed;
+}
+function resolveModelPath(modelsDir, filename) {
+	const resolvedDir = path.resolve(modelsDir);
+	const resolvedPath = path.resolve(resolvedDir, filename);
+	if (resolvedPath !== resolvedDir && !resolvedPath.startsWith(`${resolvedDir}${path.sep}`)) throw new Error("Invalid embedding model path");
+	return resolvedPath;
+}
+function downloadFile(url, dest, maxRedirects = 5) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let redirectCount = 0;
+		const request = (reqUrl) => {
+			let validatedUrl;
+			try {
+				validatedUrl = validateDownloadUrl(reqUrl);
+			} catch (error) {
+				reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid download URL"));
+				return;
+			}
+			const file = fs.createWriteStream(dest);
+			let bytesReceived = 0;
+			let expectedBytes = null;
+			const settleError = (err) => {
+				if (settled) return;
+				settled = true;
+				file.close();
+				safeUnlink(dest);
+				reject(err);
+			};
+			const settleSuccess = () => {
+				if (settled) return;
+				if (expectedBytes != null && bytesReceived !== expectedBytes) {
+					settleError(/* @__PURE__ */ new Error(`[milaidy] Download failed: bytes received (${bytesReceived}) does not match Content-Length (${expectedBytes})`));
+					return;
+				}
+				settled = true;
+				file.close();
+				resolve();
+			};
+			https.get(validatedUrl.toString(), { headers: { "User-Agent": "milaidy" } }, (res) => {
+				expectedBytes = parseContentLength(res.headers["content-length"]);
+				if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+					res.resume();
+					file.close();
+					safeUnlink(dest);
+					redirectCount += 1;
+					if (redirectCount > maxRedirects) {
+						settleError(/* @__PURE__ */ new Error(`Download failed: too many redirects (>${maxRedirects})`));
+						return;
+					}
+					let next;
+					try {
+						next = new URL(res.headers.location, validatedUrl.toString()).toString();
+					} catch {
+						settleError(/* @__PURE__ */ new Error(`Download failed: malformed redirect URL "${res.headers.location}"`));
+						return;
+					}
+					request(next);
+					return;
+				}
+				if (res.statusCode !== 200) {
+					settleError(/* @__PURE__ */ new Error(`Download failed: HTTP ${res.statusCode} for ${validatedUrl.toString()}`));
+					return;
+				}
+				res.on("data", (chunk) => {
+					bytesReceived += chunk.length;
+				});
+				res.pipe(file);
+				file.on("finish", settleSuccess);
+				file.on("error", settleError);
+			}).on("error", settleError);
+		};
+		request(url);
+	});
+}
+async function ensureModel(modelsDir, repo, filename, force = false) {
+	const safeRepo = sanitizeModelRepo(repo);
+	const safeFilename = sanitizeModelFilename(filename);
+	const modelPath = resolveModelPath(modelsDir, safeFilename);
+	if (force) safeUnlink(modelPath);
+	if (fs.existsSync(modelPath)) return modelPath;
+	const log = getLogger();
+	fs.mkdirSync(path.resolve(modelsDir), { recursive: true });
+	const url = `https://huggingface.co/${safeRepo}/resolve/main/${safeFilename}`;
+	log.info(`[milaidy] Downloading embedding model: ${safeFilename} from ${safeRepo}...`);
+	await downloadFile(url, modelPath);
+	log.info(`[milaidy] Embedding model downloaded: ${modelPath}`);
+	return modelPath;
+}
+
+//#endregion
+export { DEFAULT_IDLE_TIMEOUT_MS, DEFAULT_MODELS_DIR, EMBEDDING_META_PATH, checkDimensionMigration, ensureModel, getErrorMessage, getLogger, isCorruptedModelLoadError, readEmbeddingMeta, safeUnlink };

package/dist/runtime/embedding-manager.js

@@ -0,0 +1,193 @@
+import { DEFAULT_IDLE_TIMEOUT_MS, DEFAULT_MODELS_DIR, EMBEDDING_META_PATH, checkDimensionMigration, ensureModel, getErrorMessage, getLogger, isCorruptedModelLoadError, readEmbeddingMeta, safeUnlink } from "./embedding-manager-support.js";
+import { detectEmbeddingPreset } from "./embedding-presets.js";
+
+//#region src/runtime/embedding-manager.ts
+/**
+* MiladyEmbeddingManager — wraps node-llama-cpp to provide:
+*   • Metal GPU acceleration on Apple Silicon (gpuLayers: "auto")
+*   • Configurable embedding model with hardware-adaptive defaults
+*   • Idle timeout unloading (default: 30 min) with transparent lazy re-init
+*   • Dimension migration detection with warning logging
+*/
+var MiladyEmbeddingManager = class {
+	constructor(config = {}) {
+		this.llama = null;
+		this.embeddingModel = null;
+		this.embeddingContext = null;
+		this.initialized = false;
+		this.initializing = null;
+		this.lastUsedAt = null;
+		this.idleTimer = null;
+		this.disposed = false;
+		this.inFlightCount = 0;
+		this.unloading = null;
+		this.dimensionCheckDone = false;
+		const detected = detectEmbeddingPreset();
+		this.model = config.model ?? detected.model;
+		this.modelRepo = config.modelRepo ?? detected.modelRepo;
+		this.dimensions = config.dimensions ?? detected.dimensions;
+		this.gpuLayers = config.gpuLayers ?? detected.gpuLayers;
+		this.idleTimeoutMs = config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+		this.modelsDir = config.modelsDir ?? DEFAULT_MODELS_DIR;
+	}
+	async generateEmbedding(text) {
+		if (this.disposed) throw new Error("[milaidy] EmbeddingManager has been disposed");
+		if (this.unloading) await this.unloading;
+		await this.ensureInitialized();
+		this.inFlightCount += 1;
+		this.lastUsedAt = Date.now();
+		try {
+			if (!this.embeddingContext) throw new Error("[milaidy] Embedding context not available after init");
+			const result = await this.embeddingContext.getEmbeddingFor(text);
+			return Array.from(result.vector);
+		} catch (err) {
+			getLogger().error(`[milaidy] Embedding generation failed: ${err}`);
+			return new Array(this.dimensions).fill(0);
+		} finally {
+			this.inFlightCount -= 1;
+		}
+	}
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		await this.releaseResources();
+	}
+	isLoaded() {
+		return this.initialized && this.embeddingModel !== null;
+	}
+	getStats() {
+		return {
+			lastUsedAt: this.lastUsedAt,
+			isLoaded: this.isLoaded(),
+			model: this.model,
+			gpuLayers: this.gpuLayers,
+			dimensions: this.dimensions
+		};
+	}
+	async ensureInitialized() {
+		if (this.initialized && this.embeddingModel && this.embeddingContext) return;
+		if (this.initializing) {
+			await this.initializing;
+			return;
+		}
+		this.initializing = this.doInit();
+		try {
+			await this.initializing;
+		} finally {
+			this.initializing = null;
+		}
+	}
+	async doInit() {
+		const log = getLogger();
+		if (!this.dimensionCheckDone) {
+			checkDimensionMigration(this.model, this.dimensions);
+			this.dimensionCheckDone = true;
+		}
+		const modelPath = await ensureModel(this.modelsDir, this.modelRepo, this.model);
+		const { getLlama, LlamaLogLevel } = await import("node-llama-cpp");
+		log.info(`[milaidy] Initializing embedding model: ${this.model} (dims=${this.dimensions}, gpuLayers=${this.gpuLayers})`);
+		if (!this.llama) this.llama = await getLlama({
+			logLevel: LlamaLogLevel.error,
+			logger: (level, message) => {
+				if (level === "error" || level === "fatal") {
+					const text = message.trim();
+					if (text) log.error(`[node-llama-cpp] ${text}`);
+				}
+			}
+		});
+		const loadOpts = {
+			modelPath,
+			gpuLayers: this.gpuLayers
+		};
+		let model;
+		try {
+			model = await this.llama.loadModel(loadOpts);
+		} catch (err) {
+			if (!isCorruptedModelLoadError(err)) throw err;
+			const failureMessage = getErrorMessage(err);
+			safeUnlink(modelPath);
+			log.warn(`[milaidy] Embedding model load failed due to a likely corrupted/incomplete file (${failureMessage}) at ${modelPath}. Deleting file and re-downloading, then retrying once.`);
+			try {
+				const recoveredPath = await ensureModel(this.modelsDir, this.modelRepo, this.model, true);
+				model = await this.llama.loadModel({
+					...loadOpts,
+					modelPath: recoveredPath
+				});
+			} catch (retryErr) {
+				safeUnlink(modelPath);
+				throw retryErr;
+			}
+		}
+		let context;
+		try {
+			context = await model.createEmbeddingContext();
+		} catch (err) {
+			if (isCorruptedModelLoadError(err)) safeUnlink(modelPath);
+			try {
+				await model.dispose();
+			} catch {}
+			throw err;
+		}
+		this.embeddingModel = model;
+		this.embeddingContext = context;
+		this.initialized = true;
+		log.info(`[milaidy] Embedding model loaded: ${this.model}`);
+		this.startIdleTimer();
+	}
+	startIdleTimer() {
+		this.stopIdleTimer();
+		if (this.idleTimeoutMs <= 0) return;
+		const checkIntervalMs = Math.min(this.idleTimeoutMs, 6e4);
+		this.idleTimer = setInterval(() => {
+			if (this.inFlightCount > 0) return;
+			if (this.lastUsedAt && Date.now() - this.lastUsedAt > this.idleTimeoutMs) {
+				getLogger().info(`[milaidy] Embedding model idle for >${Math.round(this.idleTimeoutMs / 6e4)} min — unloading to free memory`);
+				this.idleUnload();
+			}
+		}, checkIntervalMs);
+		if (this.idleTimer && typeof this.idleTimer === "object" && "unref" in this.idleTimer) this.idleTimer.unref();
+	}
+	stopIdleTimer() {
+		if (this.idleTimer !== null) {
+			clearInterval(this.idleTimer);
+			this.idleTimer = null;
+		}
+	}
+	async idleUnload() {
+		this.stopIdleTimer();
+		const unloadWork = this.releaseModelResources().then(() => {
+			this.initialized = false;
+			this.unloading = null;
+		});
+		this.unloading = unloadWork;
+		await unloadWork;
+	}
+	async releaseModelResources() {
+		const log = getLogger();
+		if (this.embeddingContext) {
+			try {
+				await this.embeddingContext.dispose();
+			} catch (err) {
+				log.warn(`[milaidy] Error disposing embedding context: ${err}`);
+			}
+			this.embeddingContext = null;
+		}
+		if (this.embeddingModel) {
+			try {
+				await this.embeddingModel.dispose();
+			} catch (err) {
+				log.warn(`[milaidy] Error disposing embedding model: ${err}`);
+			}
+			this.embeddingModel = null;
+		}
+	}
+	async releaseResources() {
+		this.stopIdleTimer();
+		await this.releaseModelResources();
+		this.llama = null;
+		this.initialized = false;
+	}
+};
+
+//#endregion
+export { MiladyEmbeddingManager };

package/dist/runtime/embedding-presets.js

@@ -0,0 +1,54 @@
+import os from "node:os";
+
+//#region src/runtime/embedding-presets.ts
+/** All available presets, indexed by tier. */
+const EMBEDDING_PRESETS = {
+	fallback: {
+		tier: "fallback",
+		label: "Efficient (CPU)",
+		description: "768-dim, 74MB download — best for Intel Macs and low-RAM machines",
+		model: "nomic-embed-text-v1.5.Q4_K_S.gguf",
+		modelRepo: "nomic-ai/nomic-embed-text-v1.5-GGUF",
+		dimensions: 768,
+		gpuLayers: 0,
+		contextSize: 8192,
+		downloadSizeMB: 74
+	},
+	standard: {
+		tier: "standard",
+		label: "Balanced (Metal GPU)",
+		description: "768-dim, 95MB download — great quality with Metal acceleration",
+		model: "nomic-embed-text-v1.5.Q5_K_M.gguf",
+		modelRepo: "nomic-ai/nomic-embed-text-v1.5-GGUF",
+		dimensions: 768,
+		gpuLayers: "auto",
+		contextSize: 8192,
+		downloadSizeMB: 95
+	},
+	performance: {
+		tier: "performance",
+		label: "Maximum (7B model)",
+		description: "4096-dim, 4.2GB download — SOTA retrieval quality, 32K context",
+		model: "ggml-e5-mistral-7b-instruct-q4_k_m.gguf",
+		modelRepo: "dranger003/e5-mistral-7b-instruct-GGUF",
+		dimensions: 4096,
+		gpuLayers: "auto",
+		contextSize: 32768,
+		downloadSizeMB: 4200
+	}
+};
+const BYTES_PER_GB = 1024 ** 3;
+/** Detect the best embedding tier for the current hardware. */
+function detectEmbeddingTier() {
+	const totalRamGB = Math.round(os.totalmem() / BYTES_PER_GB);
+	if (!(process.platform === "darwin" && process.arch === "arm64") || totalRamGB <= 8) return "fallback";
+	if (totalRamGB >= 128) return "performance";
+	return "standard";
+}
+/** Get the preset for the current hardware. */
+function detectEmbeddingPreset() {
+	return EMBEDDING_PRESETS[detectEmbeddingTier()];
+}
+
+//#endregion
+export { EMBEDDING_PRESETS, detectEmbeddingPreset };

package/dist/runtime/embedding-state.js

@@ -0,0 +1,8 @@
+//#region src/runtime/embedding-state.ts
+let _state = null;
+function getEmbeddingState() {
+	return _state;
+}
+
+//#endregion
+export { getEmbeddingState };

package/dist/runtime/milady-plugin.js

@@ -0,0 +1,90 @@
+import { EMOTE_CATALOG } from "../emotes/catalog.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "../providers/workspace.js";
+import { loadCustomActions, setCustomActionsRuntime } from "./custom-actions.js";
+import { registerTriggerTaskWorker } from "../triggers/runtime.js";
+import { emoteAction } from "../actions/emote.js";
+import { restartAction } from "../actions/restart.js";
+import { sendMessageAction } from "../actions/send-message.js";
+import { adminTrustProvider } from "../providers/admin-trust.js";
+import { createAutonomousStateProvider, ensureAutonomousStateTracking } from "../providers/autonomous-state.js";
+import { createSessionKeyProvider } from "../providers/session-bridge.js";
+import { getSessionProviders, resolveDefaultSessionStorePath } from "../providers/session-utils.js";
+import { createChannelProfileProvider } from "../providers/simple-mode.js";
+import { uiCatalogProvider } from "../providers/ui-catalog.js";
+import { createWorkspaceProvider } from "../providers/workspace-provider.js";
+import { createTriggerTaskAction } from "../triggers/action.js";
+
+//#region src/runtime/milady-plugin.ts
+function createMiladyPlugin(config) {
+	const workspaceDir = config?.workspaceDir ?? DEFAULT_AGENT_WORKSPACE_DIR;
+	const agentId = config?.agentId ?? "main";
+	const sessionStorePath = config?.sessionStorePath ?? resolveDefaultSessionStorePath(agentId);
+	const baseProviders = [
+		createChannelProfileProvider(),
+		createWorkspaceProvider({
+			workspaceDir,
+			maxCharsPerFile: config?.bootstrapMaxChars
+		}),
+		adminTrustProvider,
+		createAutonomousStateProvider(),
+		createSessionKeyProvider({ defaultAgentId: agentId }),
+		...getSessionProviders({ storePath: sessionStorePath })
+	];
+	const emoteProvider = {
+		name: "emotes",
+		description: "Available avatar emote animations",
+		async get(_runtime, _message, _state) {
+			if ((_runtime.character?.settings)?.DISABLE_EMOTES) return { text: "" };
+			return { text: [
+				"## Available Emotes",
+				"",
+				"You can play emote animations on your 3D avatar using the PLAY_EMOTE action.",
+				"Use emotes sparingly and naturally during conversation to express yourself.",
+				"",
+				`Available emote IDs: ${EMOTE_CATALOG.map((e) => e.id).join(", ")}`
+			].join("\n") };
+		}
+	};
+	const customActionsProvider = {
+		name: "customActions",
+		description: "User-defined custom actions",
+		async get() {
+			const customActions = loadCustomActions();
+			if (customActions.length === 0) return { text: "" };
+			return { text: [
+				"## Custom Actions",
+				"",
+				"The following custom actions are available:",
+				...customActions.map((a) => {
+					const params = a.parameters?.map((p) => `${p.name}${p.required ? " (required)" : ""}`).join(", ") || "none";
+					return `- **${a.name}**: ${a.description} [params: ${params}]`;
+				})
+			].join("\n") };
+		}
+	};
+	return {
+		name: "milady",
+		description: "Milady workspace context, session keys, and lifecycle actions",
+		init: async (_pluginConfig, runtime) => {
+			registerTriggerTaskWorker(runtime);
+			ensureAutonomousStateTracking(runtime);
+			setCustomActionsRuntime(runtime);
+		},
+		providers: [
+			...baseProviders,
+			uiCatalogProvider,
+			emoteProvider,
+			customActionsProvider
+		],
+		actions: [
+			restartAction,
+			sendMessageAction,
+			createTriggerTaskAction,
+			emoteAction,
+			...loadCustomActions()
+		]
+	};
+}
+
+//#endregion
+export { createMiladyPlugin };

package/dist/runtime/onboarding-names.js

@@ -0,0 +1,78 @@
+//#region src/runtime/onboarding-names.ts
+/**
+* Shared pool of Japanese agent names for onboarding.
+*
+* Used by both the CLI first-run flow (eliza.ts) and the
+* web UI API server (api/server.ts).
+*/
+/** Pool of Japanese names to randomly sample from during onboarding. */
+const AGENT_NAME_POOL = [
+	"Reimu",
+	"Sakuya",
+	"Yukari",
+	"Marisa",
+	"Youmu",
+	"Koakuma",
+	"Reisen",
+	"Yuyuko",
+	"Aya",
+	"Ran",
+	"Sanae",
+	"Suika",
+	"Koishi",
+	"Nue",
+	"Chen",
+	"Mokou",
+	"Satori",
+	"Remilia",
+	"Suwako",
+	"Momiji",
+	"Tenshi",
+	"Kaguya",
+	"Komachi",
+	"Nitori",
+	"Charlotte",
+	"Kasen",
+	"Mima",
+	"Yuuka",
+	"Kogasa",
+	"Rin",
+	"Tewi",
+	"Eirin",
+	"Hina",
+	"Kagerou",
+	"Sumireko",
+	"Kokoro",
+	"Mamizou",
+	"Rinnosuke",
+	"Yumemi",
+	"Akyuu",
+	"Kanako",
+	"Hatsune",
+	"Shinki",
+	"Shion",
+	"Daiyousei",
+	"Iku",
+	"Miya",
+	"Mai",
+	"Meira",
+	"Murasa",
+	"Usagi",
+	"Rei",
+	"Yumi",
+	"Miku",
+	"Kira"
+];
+/** Pick `count` unique random names from the pool using Fisher-Yates shuffle. */
+function pickRandomNames(count) {
+	const clamped = Math.max(0, Math.min(count, AGENT_NAME_POOL.length));
+	const pool = [...AGENT_NAME_POOL];
+	for (let i = pool.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[pool[i], pool[j]] = [pool[j], pool[i]];
+	}
+	return pool.slice(0, clamped);
+}
+
+//#endregion
+export { pickRandomNames };

package/dist/runtime/restart.js

@@ -0,0 +1,40 @@
+import process from "node:process";
+
+//#region src/runtime/restart.ts
+/**
+* Restart infrastructure for Milady.
+*
+* Provides a pluggable restart handler so the restart action (and the
+* `/api/agent/restart` endpoint) work in every host environment:
+*
+*   - **CLI** (default): exits with {@link RESTART_EXIT_CODE} (75). The runner
+*     script (`scripts/run-node.mjs`) catches this, rebuilds if source files
+*     changed, and relaunches.
+*   - **Dev-server / API**: the host registers a handler via
+*     {@link setRestartHandler} that stops the current runtime, creates a new
+*     one, and hot-swaps references.
+*   - **Electron app**: the host registers a handler that calls
+*     `AgentManager.restart()`.
+*
+* @module restart
+*/
+/**
+* Special exit code that tells the CLI runner to restart the process.
+* Must stay in sync with `RESTART_EXIT_CODE` in `scripts/run-node.mjs`.
+*/
+const RESTART_EXIT_CODE = 75;
+let _handler = () => {
+	process.exit(RESTART_EXIT_CODE);
+};
+/**
+* Trigger a restart.  Delegates to whatever handler is currently registered.
+*
+* Safe to call from the restart action, the API endpoint, or any other code
+* that needs to bounce the agent.
+*/
+function requestRestart(reason) {
+	return _handler(reason);
+}
+
+//#endregion
+export { requestRestart };

package/dist/runtime/version.js

@@ -0,0 +1,7 @@
+import { resolveMiladyVersion } from "../version-resolver.js";
+
+//#region src/runtime/version.ts
+const VERSION = resolveMiladyVersion(import.meta.url);
+
+//#endregion
+export { VERSION };