miladyai 2.0.0-alpha.27

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require };

package/dist/actions/emote.js

@@ -0,0 +1,64 @@
+import { EMOTE_BY_ID } from "../emotes/catalog.js";
+
+//#region src/actions/emote.ts
+/** API port for posting emote requests. */
+const API_PORT = process.env.API_PORT || process.env.SERVER_PORT || "2138";
+const emoteAction = {
+	name: "PLAY_EMOTE",
+	similes: [
+		"EMOTE",
+		"ANIMATE",
+		"GESTURE",
+		"DANCE",
+		"WAVE",
+		"PLAY_ANIMATION",
+		"DO_EMOTE",
+		"PERFORM"
+	],
+	description: "Play an emote animation on the avatar. Emotes are visual gestures or animations that express emotion or action (e.g., wave, dance, cheer).",
+	validate: async (_runtime, _message, _state) => {
+		return true;
+	},
+	handler: async (_runtime, _message, _state, options) => {
+		try {
+			const params = options?.parameters;
+			const emoteId = typeof params?.emote === "string" ? params.emote : void 0;
+			if (!emoteId) return {
+				text: "",
+				success: false
+			};
+			const emote = EMOTE_BY_ID.get(emoteId);
+			if (!emote) return {
+				text: "",
+				success: false
+			};
+			if (!(await fetch(`http://localhost:${API_PORT}/api/emote`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ emoteId: emote.id })
+			})).ok) return {
+				text: "",
+				success: false
+			};
+			return {
+				text: `*${emote.name.toLowerCase()}s*`,
+				success: true,
+				data: { emoteId: emote.id }
+			};
+		} catch (_err) {
+			return {
+				text: "",
+				success: false
+			};
+		}
+	},
+	parameters: [{
+		name: "emote",
+		description: "The emote ID to play",
+		required: true,
+		schema: { type: "string" }
+	}]
+};
+
+//#endregion
+export { emoteAction };

package/dist/actions/restart.js

@@ -0,0 +1,81 @@
+import { requestRestart } from "../runtime/restart.js";
+import { logger } from "@elizaos/core";
+import crypto from "node:crypto";
+
+//#region src/actions/restart.ts
+/**
+* RESTART_AGENT action — gracefully restarts the agent.
+*
+* When triggered the action:
+*   1. Persists a "Restarting…" memory so the event is visible in logs
+*   2. Returns a brief restart notice to the caller
+*   3. After a short delay (so the response can flush), invokes
+*      {@link requestRestart} which delegates to the registered
+*      {@link RestartHandler}.
+*
+* In CLI mode the default handler exits with code 75 so the runner script
+* rebuilds and relaunches. In headless / Electron mode a custom handler
+* performs an in-process restart (stop → re-init → hot-swap references).
+*
+* @module actions/restart
+*/
+/** Small delay (ms) before restarting so the response has time to flush. */
+const SHUTDOWN_DELAY_MS = 1500;
+const restartAction = {
+	name: "RESTART_AGENT",
+	similes: [
+		"RESTART",
+		"REBOOT",
+		"RELOAD",
+		"REFRESH",
+		"RESPAWN",
+		"RESTART_SELF",
+		"REBOOT_AGENT",
+		"RELOAD_AGENT"
+	],
+	description: "Restart the agent process. This stops the runtime, rebuilds if source files changed, and relaunches — picking up new code, config, or plugins.",
+	validate: async (_runtime, _message, _state) => {
+		return true;
+	},
+	handler: async (runtime, message, _state, options) => {
+		const params = options?.parameters;
+		const reason = typeof params?.reason === "string" ? params.reason : void 0;
+		const restartText = reason ? `Restarting… (${reason})` : "Restarting…";
+		logger.info(`[milady] ${restartText}`);
+		try {
+			const restartMemory = {
+				id: crypto.randomUUID(),
+				entityId: runtime.agentId,
+				roomId: message.roomId,
+				worldId: message.worldId,
+				content: {
+					text: restartText,
+					source: "milady",
+					type: "system"
+				}
+			};
+			await runtime.createMemory(restartMemory, "messages");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			logger.warn(`[milady] Could not persist restart memory: ${msg}`);
+		}
+		setTimeout(() => {
+			requestRestart(reason);
+		}, SHUTDOWN_DELAY_MS);
+		return {
+			text: restartText,
+			success: true,
+			values: { restarting: true },
+			data: { reason }
+		};
+	},
+	parameters: [{
+		name: "reason",
+		description: "Optional reason for the restart (logged for diagnostics).",
+		required: false,
+		schema: { type: "string" }
+	}]
+};
+
+//#endregion
+export { restartAction };

package/dist/actions/send-message.js

@@ -0,0 +1,152 @@
+//#region src/actions/send-message.ts
+const sendMessageAction = {
+	name: "SEND_MESSAGE",
+	similes: [
+		"DM",
+		"MESSAGE",
+		"SEND_DM",
+		"POST_MESSAGE"
+	],
+	description: "Send a message to a user or room on a specific platform/service using explicit parameters.",
+	validate: async () => true,
+	handler: async (runtime, _message, _state, options) => {
+		const params = options?.parameters;
+		const targetType = params?.targetType === "user" || params?.targetType === "room" ? params.targetType : null;
+		const source = typeof params?.source === "string" ? params.source.trim() : "";
+		const target = typeof params?.target === "string" ? params.target.trim() : "";
+		const text = typeof params?.text === "string" ? params.text.trim() : "";
+		if (!targetType || !source || !target || !text) return {
+			text: "SEND_MESSAGE requires targetType, source, target, and text parameters.",
+			success: false,
+			values: {
+				success: false,
+				error: "INVALID_PARAMETERS"
+			},
+			data: {
+				actionName: "SEND_MESSAGE",
+				targetType,
+				source: source || null,
+				target: target || null
+			}
+		};
+		const service = runtime.getService(source);
+		if (!service) return {
+			text: `Message service '${source}' is not available.`,
+			success: false,
+			values: {
+				success: false,
+				error: "SERVICE_NOT_FOUND"
+			},
+			data: {
+				actionName: "SEND_MESSAGE",
+				targetType,
+				source,
+				target
+			}
+		};
+		if (targetType === "user") {
+			if (!service.sendDirectMessage) return {
+				text: `Direct messaging is not supported by '${source}'.`,
+				success: false,
+				values: {
+					success: false,
+					error: "DIRECT_MESSAGE_UNSUPPORTED"
+				},
+				data: {
+					actionName: "SEND_MESSAGE",
+					targetType,
+					source,
+					target
+				}
+			};
+			await service.sendDirectMessage(target, {
+				text,
+				source
+			});
+			return {
+				text: `Message sent to user ${target} on ${source}.`,
+				success: true,
+				values: {
+					success: true,
+					targetType,
+					source,
+					target
+				},
+				data: {
+					actionName: "SEND_MESSAGE",
+					targetType,
+					source,
+					target,
+					text
+				}
+			};
+		}
+		if (!service.sendRoomMessage) return {
+			text: `Room messaging is not supported by '${source}'.`,
+			success: false,
+			values: {
+				success: false,
+				error: "ROOM_MESSAGE_UNSUPPORTED"
+			},
+			data: {
+				actionName: "SEND_MESSAGE",
+				targetType,
+				source,
+				target
+			}
+		};
+		await service.sendRoomMessage(target, {
+			text,
+			source
+		});
+		return {
+			text: `Message sent to room ${target} on ${source}.`,
+			success: true,
+			values: {
+				success: true,
+				targetType,
+				source,
+				target
+			},
+			data: {
+				actionName: "SEND_MESSAGE",
+				targetType,
+				source,
+				target,
+				text
+			}
+		};
+	},
+	parameters: [
+		{
+			name: "targetType",
+			description: "Target entity type: user or room.",
+			required: true,
+			schema: {
+				type: "string",
+				enum: ["user", "room"]
+			}
+		},
+		{
+			name: "source",
+			description: "Messaging source/service name (e.g. telegram, discord).",
+			required: true,
+			schema: { type: "string" }
+		},
+		{
+			name: "target",
+			description: "Target identifier. For users: entity ID/username. For rooms: room ID/name.",
+			required: true,
+			schema: { type: "string" }
+		},
+		{
+			name: "text",
+			description: "Message text to send.",
+			required: true,
+			schema: { type: "string" }
+		}
+	]
+};
+
+//#endregion
+export { sendMessageAction };

package/dist/agent-admin-routes.js

@@ -0,0 +1,82 @@
+//#region src/api/agent-admin-routes.ts
+async function handleAgentAdminRoutes(ctx) {
+	const { res, method, pathname, state, onRestart, json, error, resolveStateDir, resolvePath, getHomeDir, isSafeResetStateDir, stateDirExists, removeStateDir, logWarn } = ctx;
+	if (method === "POST" && pathname === "/api/agent/restart") {
+		if (!onRestart) {
+			error(res, "Restart is not supported in this mode (no restart handler registered)", 501);
+			return true;
+		}
+		if (state.agentState === "restarting") {
+			error(res, "A restart is already in progress", 409);
+			return true;
+		}
+		const previousState = state.agentState;
+		state.agentState = "restarting";
+		try {
+			const newRuntime = await onRestart();
+			if (newRuntime) {
+				state.runtime = newRuntime;
+				state.chatConnectionReady = null;
+				state.chatConnectionPromise = null;
+				state.agentState = "running";
+				state.agentName = newRuntime.character.name ?? "Milady";
+				state.startedAt = Date.now();
+				state.pendingRestartReasons = [];
+				json(res, {
+					ok: true,
+					pendingRestart: false,
+					status: {
+						state: state.agentState,
+						agentName: state.agentName,
+						startedAt: state.startedAt
+					}
+				});
+			} else {
+				state.agentState = previousState;
+				error(res, "Restart handler returned null — runtime failed to re-initialize", 500);
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			state.agentState = previousState;
+			error(res, `Restart failed: ${message}`, 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/agent/reset") {
+		try {
+			if (state.runtime) {
+				try {
+					await state.runtime.stop();
+				} catch (stopErr) {
+					logWarn(`[milady-api] Error stopping runtime during reset: ${stopErr instanceof Error ? stopErr.message : String(stopErr)}`);
+				}
+				state.runtime = null;
+			}
+			const resolvedState = resolvePath(resolveStateDir());
+			if (!isSafeResetStateDir(resolvedState, getHomeDir())) {
+				logWarn(`[milady-api] Refusing to delete unsafe state dir: "${resolvedState}"`);
+				error(res, `Reset aborted: state directory "${resolvedState}" does not appear safe to delete`, 400);
+				return true;
+			}
+			if (stateDirExists(resolvedState)) removeStateDir(resolvedState);
+			state.agentState = "stopped";
+			state.agentName = "Milady";
+			state.model = void 0;
+			state.startedAt = void 0;
+			state.config = {};
+			state.chatRoomId = null;
+			state.chatUserId = null;
+			state.chatConnectionReady = null;
+			state.chatConnectionPromise = null;
+			state.pendingRestartReasons = [];
+			json(res, { ok: true });
+		} catch (err) {
+			error(res, `Reset failed: ${err instanceof Error ? err.message : String(err)}`, 500);
+		}
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleAgentAdminRoutes };

package/dist/agent-lifecycle-routes.js

@@ -0,0 +1,79 @@
+import { getAutonomySvc } from "./autonomy-routes.js";
+
+//#region src/api/agent-lifecycle-routes.ts
+function detectModel(runtime) {
+	if (!runtime) return "unknown";
+	return runtime.plugins.find((plugin) => plugin.name.includes("anthropic") || plugin.name.includes("openai") || plugin.name.includes("groq"))?.name ?? "unknown";
+}
+async function handleAgentLifecycleRoutes(ctx) {
+	const { res, method, pathname, state, json } = ctx;
+	if (method === "POST" && pathname === "/api/agent/start") {
+		state.agentState = "running";
+		state.startedAt = Date.now();
+		state.model = detectModel(state.runtime);
+		const svc = getAutonomySvc(state.runtime);
+		if (svc) await svc.enableAutonomy();
+		json(res, {
+			ok: true,
+			status: {
+				state: state.agentState,
+				agentName: state.agentName,
+				model: state.model,
+				uptime: 0,
+				startedAt: state.startedAt
+			}
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/agent/stop") {
+		const svc = getAutonomySvc(state.runtime);
+		if (svc) await svc.disableAutonomy();
+		state.agentState = "stopped";
+		state.startedAt = void 0;
+		state.model = void 0;
+		json(res, {
+			ok: true,
+			status: {
+				state: state.agentState,
+				agentName: state.agentName
+			}
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/agent/pause") {
+		const svc = getAutonomySvc(state.runtime);
+		if (svc) await svc.disableAutonomy();
+		state.agentState = "paused";
+		json(res, {
+			ok: true,
+			status: {
+				state: state.agentState,
+				agentName: state.agentName,
+				model: state.model,
+				uptime: state.startedAt ? Date.now() - state.startedAt : void 0,
+				startedAt: state.startedAt
+			}
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/agent/resume") {
+		const svc = getAutonomySvc(state.runtime);
+		if (svc) await svc.enableAutonomy();
+		state.agentState = "running";
+		json(res, {
+			ok: true,
+			status: {
+				state: state.agentState,
+				agentName: state.agentName,
+				model: state.model,
+				uptime: state.startedAt ? Date.now() - state.startedAt : void 0,
+				startedAt: state.startedAt
+			}
+		});
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleAgentLifecycleRoutes };

package/dist/agent-transfer-routes.js

@@ -0,0 +1,102 @@
+import { AgentExportError, estimateExportSize, exportAgent, importAgent } from "./services/agent-export.js";
+import { readRequestBodyBuffer } from "./http-helpers.js";
+
+//#region src/api/agent-transfer-routes.ts
+const MAX_IMPORT_BYTES = 512 * 1048576;
+const AGENT_TRANSFER_MIN_PASSWORD_LENGTH = 4;
+const AGENT_TRANSFER_MAX_PASSWORD_LENGTH = 1024;
+function readRawBody(req, maxBytes) {
+	return readRequestBodyBuffer(req, { maxBytes }).then((body) => {
+		if (body === null) throw new Error(`Request body exceeds maximum size (${maxBytes} bytes)`);
+		return body;
+	});
+}
+async function handleAgentTransferRoutes(ctx) {
+	const { req, res, method, pathname, state, readJsonBody, json, error } = ctx;
+	if (method === "POST" && pathname === "/api/agent/export") {
+		if (!state.runtime) {
+			error(res, "Agent is not running — start it before exporting.", 503);
+			return true;
+		}
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.password || typeof body.password !== "string") {
+			error(res, `A password of at least ${AGENT_TRANSFER_MIN_PASSWORD_LENGTH} characters is required.`, 400);
+			return true;
+		}
+		if (body.password.length < AGENT_TRANSFER_MIN_PASSWORD_LENGTH) {
+			error(res, `A password of at least ${AGENT_TRANSFER_MIN_PASSWORD_LENGTH} characters is required.`, 400);
+			return true;
+		}
+		try {
+			const fileBuffer = await exportAgent(state.runtime, body.password, { includeLogs: body.includeLogs === true });
+			const filename = `${(state.runtime.character.name ?? "agent").replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase()}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}.eliza-agent`;
+			res.statusCode = 200;
+			res.setHeader("Content-Type", "application/octet-stream");
+			res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+			res.setHeader("Content-Length", fileBuffer.length);
+			res.end(fileBuffer);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (err instanceof AgentExportError) error(res, message, 400);
+			else error(res, `Export failed: ${message}`, 500);
+		}
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/agent/export/estimate") {
+		if (!state.runtime) {
+			error(res, "Agent is not running.", 503);
+			return true;
+		}
+		try {
+			json(res, await estimateExportSize(state.runtime));
+		} catch (err) {
+			error(res, `Estimate failed: ${err instanceof Error ? err.message : String(err)}`, 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/agent/import") {
+		if (!state.runtime) {
+			error(res, "Agent is not running — start it before importing.", 503);
+			return true;
+		}
+		let rawBody;
+		try {
+			rawBody = await readRawBody(req, MAX_IMPORT_BYTES);
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 413);
+			return true;
+		}
+		if (rawBody.length < 5) {
+			error(res, "Request body is too small — expected password + file data.", 400);
+			return true;
+		}
+		const passwordLength = rawBody.readUInt32BE(0);
+		if (passwordLength < AGENT_TRANSFER_MIN_PASSWORD_LENGTH) {
+			error(res, `Password must be at least ${AGENT_TRANSFER_MIN_PASSWORD_LENGTH} characters.`, 400);
+			return true;
+		}
+		if (passwordLength > AGENT_TRANSFER_MAX_PASSWORD_LENGTH) {
+			error(res, `Password is too long (max ${AGENT_TRANSFER_MAX_PASSWORD_LENGTH} bytes).`, 400);
+			return true;
+		}
+		if (rawBody.length < 4 + passwordLength + 1) {
+			error(res, "Request body is incomplete — missing file data after password.", 400);
+			return true;
+		}
+		const password = rawBody.subarray(4, 4 + passwordLength).toString("utf-8");
+		const fileBuffer = rawBody.subarray(4 + passwordLength);
+		try {
+			json(res, await importAgent(state.runtime, fileBuffer, password));
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (err instanceof AgentExportError) error(res, message, 400);
+			else error(res, `Import failed: ${message}`, 500);
+		}
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleAgentTransferRoutes };

package/dist/api/agent-admin-routes.js

@@ -0,0 +1,82 @@
+//#region src/api/agent-admin-routes.ts
+async function handleAgentAdminRoutes(ctx) {
+	const { res, method, pathname, state, onRestart, json, error, resolveStateDir, resolvePath, getHomeDir, isSafeResetStateDir, stateDirExists, removeStateDir, logWarn } = ctx;
+	if (method === "POST" && pathname === "/api/agent/restart") {
+		if (!onRestart) {
+			error(res, "Restart is not supported in this mode (no restart handler registered)", 501);
+			return true;
+		}
+		if (state.agentState === "restarting") {
+			error(res, "A restart is already in progress", 409);
+			return true;
+		}
+		const previousState = state.agentState;
+		state.agentState = "restarting";
+		try {
+			const newRuntime = await onRestart();
+			if (newRuntime) {
+				state.runtime = newRuntime;
+				state.chatConnectionReady = null;
+				state.chatConnectionPromise = null;
+				state.agentState = "running";
+				state.agentName = newRuntime.character.name ?? "Milady";
+				state.startedAt = Date.now();
+				state.pendingRestartReasons = [];
+				json(res, {
+					ok: true,
+					pendingRestart: false,
+					status: {
+						state: state.agentState,
+						agentName: state.agentName,
+						startedAt: state.startedAt
+					}
+				});
+			} else {
+				state.agentState = previousState;
+				error(res, "Restart handler returned null — runtime failed to re-initialize", 500);
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			state.agentState = previousState;
+			error(res, `Restart failed: ${message}`, 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/agent/reset") {
+		try {
+			if (state.runtime) {
+				try {
+					await state.runtime.stop();
+				} catch (stopErr) {
+					logWarn(`[milady-api] Error stopping runtime during reset: ${stopErr instanceof Error ? stopErr.message : String(stopErr)}`);
+				}
+				state.runtime = null;
+			}
+			const resolvedState = resolvePath(resolveStateDir());
+			if (!isSafeResetStateDir(resolvedState, getHomeDir())) {
+				logWarn(`[milady-api] Refusing to delete unsafe state dir: "${resolvedState}"`);
+				error(res, `Reset aborted: state directory "${resolvedState}" does not appear safe to delete`, 400);
+				return true;
+			}
+			if (stateDirExists(resolvedState)) removeStateDir(resolvedState);
+			state.agentState = "stopped";
+			state.agentName = "Milady";
+			state.model = void 0;
+			state.startedAt = void 0;
+			state.config = {};
+			state.chatRoomId = null;
+			state.chatUserId = null;
+			state.chatConnectionReady = null;
+			state.chatConnectionPromise = null;
+			state.pendingRestartReasons = [];
+			json(res, { ok: true });
+		} catch (err) {
+			error(res, `Reset failed: ${err instanceof Error ? err.message : String(err)}`, 500);
+		}
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleAgentAdminRoutes };